Public documentation for the commercial API

$headers = @{ "X-API-Key" = "YOUR_API_KEY" }
$form = @{ image = Get-Item "C:\\images\\plate.jpg" }

Invoke-RestMethod `
  -Method Post `
  -Uri "https://www.platenexus.com/api/v1/plates/recognize/" `
  -Headers $headers `
  -Form $form

import requests

with open("plate.jpg", "rb") as image_file:
    response = requests.post(
        "https://www.platenexus.com/api/v1/plates/recognize/",
        headers={"X-API-Key": "YOUR_API_KEY"},
        files={"image": image_file},
        timeout=60,
    )

print(response.status_code)
print(response.json())

const formData = new FormData();
formData.append("image", fileInput.files[0]);

const response = await fetch("https://www.platenexus.com/api/v1/plates/recognize/", {
  method: "POST",
  headers: {
    "X-API-Key": "YOUR_API_KEY"
  },
  body: formData,
});

const data = await response.json();
console.log(data);

const axios = require("axios");
const FormData = require("form-data");
const fs = require("fs");

async function recognizePlate() {
  const form = new FormData();
  form.append("image", fs.createReadStream("plate.jpg"));

  const response = await axios.post(
    "https://www.platenexus.com/api/v1/plates/recognize/",
    form,
    {
      headers: {
        "X-API-Key": "YOUR_API_KEY",
        ...form.getHeaders(),
      },
      timeout: 60000,
    }
  );

  console.log(response.data);
}

recognizePlate();

import java.io.IOException;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.UUID;

public class PlateRecognitionExample {
    public static void main(String[] args) throws IOException, InterruptedException {
        String boundary = "----platenexus-" + UUID.randomUUID();
        Path imagePath = Path.of("plate.jpg");
        byte[] fileBytes = Files.readAllBytes(imagePath);

        byte[] body = (
            "--" + boundary + "\r\n" +
            "Content-Disposition: form-data; name=\"image\"; filename=\"plate.jpg\"\r\n" +
            "Content-Type: image/jpeg\r\n\r\n"
        ).getBytes();

        byte[] closing = ("\r\n--" + boundary + "--\r\n").getBytes();
        byte[] payload = new byte[body.length + fileBytes.length + closing.length];
        System.arraycopy(body, 0, payload, 0, body.length);
        System.arraycopy(fileBytes, 0, payload, body.length, fileBytes.length);
        System.arraycopy(closing, 0, payload, body.length + fileBytes.length, closing.length);

        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://www.platenexus.com/api/v1/plates/recognize/"))
            .header("X-API-Key", "YOUR_API_KEY")
            .header("Content-Type", "multipart/form-data; boundary=" + boundary)
            .POST(HttpRequest.BodyPublishers.ofByteArray(payload))
            .build();

        HttpClient client = HttpClient.newHttpClient();
        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
        System.out.println(response.body());
    }
}

import okhttp3.MediaType.Companion.toMediaType
import okhttp3.MultipartBody
import okhttp3.OkHttpClient
import okhttp3.Request
import okhttp3.RequestBody.Companion.asRequestBody
import java.io.File

fun main() {
    val file = File("plate.jpg")
    val requestBody = MultipartBody.Builder()
        .setType(MultipartBody.FORM)
        .addFormDataPart(
            "image",
            file.name,
            file.asRequestBody("image/jpeg".toMediaType())
        )
        .build()

    val request = Request.Builder()
        .url("https://www.platenexus.com/api/v1/plates/recognize/")
        .addHeader("X-API-Key", "YOUR_API_KEY")
        .post(requestBody)
        .build()

    OkHttpClient().newCall(request).execute().use { response ->
        println(response.body?.string())
    }
}

using System.Net.Http;
using System.Net.Http.Headers;

using var client = new HttpClient();
client.DefaultRequestHeaders.Add("X-API-Key", "YOUR_API_KEY");

using var form = new MultipartFormDataContent();
using var fileStream = File.OpenRead("plate.jpg");
using var fileContent = new StreamContent(fileStream);
fileContent.Headers.ContentType = new MediaTypeHeaderValue("image/jpeg");
form.Add(fileContent, "image", "plate.jpg");

var response = await client.PostAsync("https://www.platenexus.com/api/v1/plates/recognize/", form);
var body = await response.Content.ReadAsStringAsync();
Console.WriteLine(body);

package main

import (
    "bytes"
    "io"
    "mime/multipart"
    "net/http"
    "os"
)

func main() {
    file, _ := os.Open("plate.jpg")
    defer file.Close()

    body := &bytes.Buffer{}
    writer := multipart.NewWriter(body)
    part, _ := writer.CreateFormFile("image", "plate.jpg")
    io.Copy(part, file)
    writer.Close()

    req, _ := http.NewRequest("POST", "https://www.platenexus.com/api/v1/plates/recognize/", body)
    req.Header.Set("X-API-Key", "YOUR_API_KEY")
    req.Header.Set("Content-Type", writer.FormDataContentType())

    resp, _ := http.DefaultClient.Do(req)
    defer resp.Body.Close()
    payload, _ := io.ReadAll(resp.Body)
    println(string(payload))
}

require "net/http"
require "json"

uri = URI("https://www.platenexus.com/api/v1/plates/recognize/")
request = Net::HTTP::Post.new(uri)
request["X-API-Key"] = "YOUR_API_KEY"
request.set_form([["image", File.open("plate.jpg")]], "multipart/form-data")

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == "https") do |http|
  http.request(request)
end

puts response.body

<?php

$ch = curl_init('https://www.platenexus.com/api/v1/plates/recognize/');
$data = [
    'image' => new CURLFile(__DIR__ . '/plate.jpg'),
];

curl_setopt_array($ch, [
    CURLOPT_POST => true,
    CURLOPT_HTTPHEADER => ['X-API-Key: YOUR_API_KEY'],
    CURLOPT_POSTFIELDS => $data,
    CURLOPT_RETURNTRANSFER => true,
]);

$response = curl_exec($ch);
curl_close($ch);

echo $response;