API Reference

One request. Structured vehicle data.

A single GET request turns an image into plate text, make & model, and bounding boxes. No SDK, no OAuth. Start with the quickstart below.

REST · JSON 5 region models No SDK required
Quickstart

Live in three steps

No SDK to install and no heavy onboarding. If you can make an HTTP request, you can ship.

1

Get your free API key

Sign up with your email, verify the one-time code, and your key is ready instantly.

2

Send an image URL

Call the ObjectDetection endpoint with an image URL, your key and a region. No SDK required.

3

Read the JSON

Get back the plate text, make & model, bounding boxes and confidence scores. Ship it.

GET https://84.200.6.42/ObjectDetection

Served over HTTPS. Authenticate with your API key — send it as the X-API-Key request header (recommended) or an Api_key query parameter — no OAuth. Set GA to your region: eu, me, africa, asia or us.

Samples show a placeholder key. Sign in to auto-fill your real key, or create a free account.
Request · cURL
curl -X GET "https://84.200.6.42/ObjectDetection?Image_url=https://www.focus2move.com/wp-content/uploads/2020/10/Renault-Captur-2020-1024-19.jpg&GA=eu&Detect_license_plate=true&Read_license_plate=true&Detect_make_and_model=true&Detect_vehicle_position=true&Include_additional_info=true&Input_size=416" \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "accept: */*"
Request · Python
import requests

resp = requests.get(
    "https://84.200.6.42/ObjectDetection",
    headers={"X-API-Key": "YOUR_API_KEY"},
    params={
        "Image_url": "https://www.focus2move.com/wp-content/uploads/2020/10/Renault-Captur-2020-1024-19.jpg",
        "GA": "eu",
        "Detect_license_plate": "true",
        "Read_license_plate": "true",
        "Detect_make_and_model": "true",
        "Detect_vehicle_position": "true",
        "Include_additional_info": "true",
        "Input_size": "416",
    },
)

result = resp.json()[0]
print(result["lpr"], "-", result["vmm"], "(", result["country"], ")")
Request · JavaScript
const params = new URLSearchParams({
  Image_url: "https://www.focus2move.com/wp-content/uploads/2020/10/Renault-Captur-2020-1024-19.jpg",
  GA: "eu",
  Detect_license_plate: "true",
  Read_license_plate: "true",
  Detect_make_and_model: "true",
  Detect_vehicle_position: "true",
  Include_additional_info: "true",
  Input_size: "416",
});

const res = await fetch(`https://84.200.6.42/ObjectDetection?${params}`, {
  headers: { "X-API-Key": "YOUR_API_KEY" },
});
const [result] = await res.json();
console.log(result.lpr, result.vmm, result.country);
Request · C#
using var http = new HttpClient();
http.DefaultRequestHeaders.Add("X-API-Key", "YOUR_API_KEY");

var url = "https://84.200.6.42/ObjectDetection"
    + "?Image_url=https://www.focus2move.com/wp-content/uploads/2020/10/Renault-Captur-2020-1024-19.jpg"
    + "&GA=eu"
    + "&Detect_license_plate=true&Read_license_plate=true"
    + "&Detect_make_and_model=true&Detect_vehicle_position=true"
    + "&Include_additional_info=true&Input_size=416";

var json = await http.GetStringAsync(url);
Console.WriteLine(json);
Request · PHP
<?php
$query = http_build_query([
  "Image_url" => "https://www.focus2move.com/wp-content/uploads/2020/10/Renault-Captur-2020-1024-19.jpg",
  "GA"        => "eu",
  "Detect_license_plate"    => "true",
  "Read_license_plate"      => "true",
  "Detect_make_and_model"   => "true",
  "Detect_vehicle_position" => "true",
  "Include_additional_info" => "true",
  "Input_size"              => "416",
]);

$ctx = stream_context_create(["http" => [
  "method" => "GET",
  "header" => "X-API-Key: YOUR_API_KEY\r\naccept: */*\r\n",
]]);

$response = file_get_contents("https://84.200.6.42/ObjectDetection?" . $query, false, $ctx);
$data = json_decode($response, true);
echo $data[0]["lpr"] . " - " . $data[0]["vmm"];
Request · Go
package main

import (
    "fmt"
    "io"
    "net/http"
    "net/url"
)

func main() {
    q := url.Values{}
    q.Set("Image_url", "https://www.focus2move.com/wp-content/uploads/2020/10/Renault-Captur-2020-1024-19.jpg")
    q.Set("GA", "eu")
    q.Set("Detect_license_plate", "true")
    q.Set("Read_license_plate", "true")
    q.Set("Detect_make_and_model", "true")
    q.Set("Detect_vehicle_position", "true")
    q.Set("Include_additional_info", "true")
    q.Set("Input_size", "416")

    req, _ := http.NewRequest("GET", "https://84.200.6.42/ObjectDetection?"+q.Encode(), nil)
    req.Header.Set("X-API-Key", "YOUR_API_KEY")
    resp, _ := http.DefaultClient.Do(req)
    defer resp.Body.Close()
    body, _ := io.ReadAll(resp.Body)
    fmt.Println(string(body))
}
Keep keys server-side.

Your key authenticates every call, so run the API from your own backend. Never embed it in client-side JavaScript, mobile bundles or a public repo. If a key leaks, rotate it from your dashboard.

Response

What you get back

The body is a JSON array — one object per detected vehicle. Any *Error field that is null means that stage succeeded.

Response
[
  {
    "platePosition": { "x": 242, "y": 438, "width": 142, "height": 45 },
    "platePositionConfidence": 0.853954,
    "lpr": "W571KA",
    "lprConfidence": [0.9943, 0.9998, 0.9999, 0.9988, 0.9987, 0.9915],
    "country": "France",
    "region": "F(France)",
    "vehiclePosition": { "x": 209, "y": 141, "width": 686, "height": 428 },
    "vmm": "Renault ,Captur",
    "vehicleCategory": "Car",
    "vehiclePositionConfidence": 0.938929,
    "vmmConfidence": 0.5,
    "operationTimeMS": 2873,
    "plateFinderError": null,
    "plateRecognizerError": null,
    "carFinderError": null,
    "vmmError": null
  }
]
All response fields11 fields
FieldTypeDescription
lprstringThe recognized license-plate text.
lprConfidencenumber[]Per-character confidence (0–1) for each plate character.
vmmstringVehicle make & model, e.g. "Renault ,Captur".
vehicleCategorystringHigh-level class such as Car, Truck or Bus.
countrystringResolved country of the plate.
regionstringCountry/region code and label, e.g. "F(France)".
platePositionobjectPlate bounding box: { x, y, width, height } in pixels.
vehiclePositionobjectVehicle bounding box: { x, y, width, height } in pixels.
platePositionConfidencenumberConfidence (0–1) of the plate localization.
vmmConfidencenumberConfidence (0–1) of the make & model prediction.
operationTimeMSnumberTotal inference time for the image, in milliseconds.
Limits & quotas

Rate limits & monthly quotas

Every free Cloud key shares one allowance. Usage resets at 00:00 UTC on the 1st of each month, and you can watch it live on your dashboard.

LimitFree Cloud planWhen exceeded
Request rate1 image / second per key429 with Retry-After: 1
Processing units20,000 / monthRequests declined until the 1st
Image uploads5,000 / monthUploads declined until the 1st
Image sizeUp to 5 MB, 4096 px longest side413 Payload Too Large

What counts as a processing unit?

Each stage the engine runs counts as one unit — plate-finding, plate-reading, vehicle-finding and make & model are 1 unit each. Plate-reading is charged once for every plate the finder locates (no cap per image): a plate-only call is 1 unit to find the plates plus 1 per plate read. A full call that also identifies the vehicle adds 1 vehicle-find + 1 make & model per vehicle — about 4 units for a typical single-vehicle image. Turning off the detections you don't need spends fewer.

Units are charged whether or not the call returns a result, and image uploads are counted separately against your monthly upload allowance. Your live balance is always on your dashboard — units and uploads update as you use the API.

Need more headroom?

Higher volume, burst throughput and unlimited on-premises processing are available — talk to us.

Reference

Full reference

Everything else, tucked away until you need it. Expand a section to dig in.

All request parameters10 parameters

Image_url and GA are mandatory, plus your API key — sent as the X-API-Key header (recommended) or the Api_key query parameter. The rest are optional feature toggles that default to true.

ParameterTypeRequiredDescription
Image_url string Required Publicly reachable URL of the image to analyse, or an image id returned by /UploadJpeg.
Api_key string No Your API key from the dashboard — required, but prefer the X-API-Key request header; this query parameter is a legacy alternative. Supply at least one.
GA enum Required Geographic area for the plate model: eu, me, africa, asia, us.
Detect_license_plate bool No Locate the plate region. Default true.
Read_license_plate bool No OCR the plate characters. Default true.
Detect_make_and_model bool No Identify vehicle make & model (VMM). Default true.
Detect_vehicle_position bool No Return the vehicle bounding box. Default true.
Include_additional_info bool No Include country/region and extra metadata. Default true.
Input_size int No Inference resolution (e.g. 416). Larger = more accurate, slower.
Version string No Optional model/engine version. Leave blank to use the current production model.
Region codes (GA)5 regions

Plate formats vary by part of the world, so the engine ships a model per region. Pass one as the mandatory GA parameter for the best local accuracy.

eu Europeme Middle Eastafrica Africaasia Asiaus United States
Stage error fields4 fields

Detection is a pipeline. Instead of failing the whole request, each stage reports its own error field — null means that stage succeeded. (These sit inside a successful 200 response; whole-request failures use HTTP status codes — see below.)

FieldMeaning
plateFinderError The plate-detection stage failed (e.g. no plate found or image unreadable).
plateRecognizerError The plate-OCR stage failed to read characters.
carFinderError The vehicle-detection stage failed to locate a vehicle.
vmmError The make & model recognition stage failed.
HTTP errors & status codes4 codes

When a whole request fails — a missing or invalid key, the rate limit, or an oversized image — the engine replies with an HTTP error status and a JSON envelope: message_Error, code, traceId. (Different from the per-stage *Error fields above, which live inside a 200 response.)

Error body
{
  "message_Error": "Invalid API key or incorrect product",
  "code": "InvalidApiKey",
  "traceId": "8000139c-0013-fe00-b63f-84710c7967bb"
}
StatuscodeWhen it happens
400 ApiKeyRequired No API key was sent. Add the X-API-Key header (or the Api_key query).
403 InvalidApiKey The key is unknown, or the header and query keys don't match.
413 — The image is over 5 MB or 4096 px on its longest side.
429 — More than one image per second on this key — wait for the Retry-After (1s) and retry.
Image upload

No public URL? Upload the image.

Detection needs an Image_url the engine can read. If your image lives on a local disk or behind auth, POST it straight to the engine's upload endpoint — with your API key — and get back an image id, then pass that id in as Image_url for detection.

POST https://84.200.6.42/UploadJpeg
Upload examples & detailscURL · Python · JS
  • Send the file as multipart form-data under the field name files (JPG or PNG, up to 5 MB / 4096 px).
  • Returns a bare image id (e.g. 12) — pass it in as Image_url in your detection call.
  • The API key is required — send your X-API-Key header, same as detection (a missing key returns 400 ApiKeyRequired).
Upload · cURL
curl -X POST "https://84.200.6.42/UploadJpeg" \
  -H "X-API-Key: YOUR_API_KEY" \
  -F "files=@/path/to/car.jpg"

# => 12   (a bare image id — pass it in as Image_url to ObjectDetection)
Upload · Python
import requests

with open("car.jpg", "rb") as f:
    r = requests.post(
        "https://84.200.6.42/UploadJpeg",
        headers={"X-API-Key": "YOUR_API_KEY"},
        files={"files": f},
    )

image_id = r.text.strip()   # e.g. "12" — pass this in as Image_url to ObjectDetection
print(image_id)
Upload · JavaScript
const form = new FormData();
form.append("files", fileInput.files[0]);

const res = await fetch("https://84.200.6.42/UploadJpeg", {
  method: "POST",
  headers: { "X-API-Key": "YOUR_API_KEY" },
  body: form,
});
const imageId = (await res.text()).trim();   // e.g. "12" — use as Image_url
console.log(imageId);
On-premises SDK

Running offline? Use the native SDK.

Beyond this Cloud API, the same recognition engine ships as a native Windows SDK (nnAnpr.dll) for fully on-premises deployments — with C/C++, C# and Delphi bindings, still-image and live-video / RTSP pipelines, and CPU, GPU or edge-accelerator processing.

Stuck on something? Contact support and a real engineer will get back to you.
Something went wrong. Reload ✕