Egyptian Car License OCR API:
Extract Vehicle & Owner Data in One Request

Parking systems, security checkpoints, fleet management platforms, and traffic enforcement tools all need to read Egyptian vehicle registration documents — and they all face the same problem: the car license is a dense, bilingual document that generic OCR handles poorly. SignMe extracts every field in under 400ms with a single API call, returning typed JSON ready to feed directly into your database.

What Is Egyptian Car License OCR?

An Egyptian car license (رخصة السيارة) is the vehicle registration document that travels with the car — distinct from the driver's personal driving license. It contains the vehicle's plate number, make, model, year, engine number, chassis number, registration and expiry dates, and the registered owner's full name in Arabic and English plus their national ID number.

Egyptian Car License OCR is the automated extraction of all these fields from a scanned or photographed car license image using a REST API. The output is a structured JSON object with named, typed fields — no raw text, no post-processing required. Pass ID_type=3 to the SignMe endpoint and it handles the rest.

This is the same endpoint used for National ID and driver license extraction — one integration covers all Egyptian document types.

Why Egyptian Vehicle Registration Documents Are Difficult to Process

Dense bilingual layout with no standard spacing

Egyptian car licenses pack two languages, vehicle technical data, and owner identity data into a compact card format. Arabic text runs right-to-left alongside English labels and numeric fields. Generic OCR engines that treat the document as a flat image routinely misalign field boundaries, merge adjacent values, or return one language while discarding the other. For any system that must match against Arabic-language government databases, a missing Arabic owner name is not a recoverable error.

Vehicle identifiers require exact accuracy

Engine numbers and chassis numbers are long alphanumeric strings used for vehicle identity verification. A single transposed character produces a mismatch against traffic authority records. These fields are typically printed in a small font on worn laminate, which compounds the challenge for general-purpose models not specifically trained on Egyptian registration documents.

Documents degrade in real-world scanning conditions

Car licenses are scanned at parking barriers, roadside checkpoints, and insurance branches — often from a mobile camera, under variable lighting, with the document flat on a dashboard or held at an angle. Cards that have spent years in a glove compartment show crease marks, faded print, and scratched laminate. A production API must return accurate results across all of these conditions, not just clean, flat, well-lit scans.

How SignMe API Solves This

SignMe is trained specifically on Egyptian vehicle registration documents, not adapted from a generic document model. Capabilities relevant to vehicle registration extraction:

• Bilingual owner data — Arabic and English owner name returned as separate fields in every response.
• National ID extraction — the owner's national ID printed on the car license is parsed and returned as a standalone field for cross-referencing.
• Vehicle identifiers as exact strings — engine number and chassis number are returned as raw strings with no normalisation that could alter the value.
• ISO 8601 expiry date — directly comparable to Date.now(); no date-parsing logic needed in your application.
• Confidence score per response — programmatically flag low-confidence results before they reach business logic.
• Under 400ms average — fast enough for gate-control and synchronous onboarding flows.
• Failed calls not charged — credits are only consumed on successful extraction.

See pricing and credit bundles for all plan options, including high-volume and enterprise tiers.

Example API Response

A representative response for an Egyptian car license scan (ID_type=3):

{
  "status": "success",
  "data": {
    "plate_number":    "أ ب ج 1234",
    "owner_name":      "خالد محمود عبد الرحمن",
    "owner_name_en":   "Khaled Mahmoud Abd El-Rahman",
    "owner_national_id": "28901041234567",
    "vehicle_make":    "Toyota",
    "vehicle_model":   "Corolla",
    "vehicle_year":    "2019",
    "vehicle_color":   "White",
    "engine_number":   "2ZR1234567",
    "chassis_number":  "JTDBR32E890123456",
    "registration_date": "2023-01-15",
    "expiry_date":       "2025-01-15",
    "governorate":     "Cairo"
  },
  "confidence":        0.96,
  "credits_used":      1,
  "response_time_ms":  312
}

engine_number and chassis_number are returned as exact strings — no normalisation applied. expiry_date is ISO 8601, so a validity check is a single comparison: new Date(data.expiry_date) > new Date(). Failed API calls are not billed.

How to Integrate in 3 Steps

1. 1
   Get your API key

   Create a free account. The free tier includes 100 API calls — enough to build and fully test a vehicle registration integration. No credit card required.
2. 2
   POST the car license image

   Send a multipart/form-data POST with your API key in the Authorization header and ID_type=3 to identify the document as a vehicle registration card.
3. 3
   Use the structured response

   Read the typed JSON fields directly into your database or business logic. No regex, no field mapping, no post-processing. The response is ready to use as-is.

curl -X POST \
  "https://mobapi.signme.it/api/v2/SignMeAPI/uploadImage?ID_type=3" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: multipart/form-data" \
  -F "file=@/path/to/car-license.jpg"

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

const res = await fetch(
  "https://mobapi.signme.it/api/v2/SignMeAPI/uploadImage?ID_type=3",
  {
    method: "POST",
    headers: { "Authorization": "Bearer YOUR_API_KEY" },
    body: form,
  }
);

const { data } = await res.json();

console.log(data.plate_number);      // "أ ب ج 1234"
console.log(data.owner_name_en);     // "Khaled Mahmoud Abd El-Rahman"
console.log(data.chassis_number);    // "JTDBR32E890123456"
console.log(data.expiry_date);       // "2025-01-15"

// Validity check — no date parsing needed
const isValid = new Date(data.expiry_date) > new Date();

Full code examples in Python, C#, and Dart are available in the API documentation.

Use Cases

Parking Management Systems

Modern parking systems need to identify vehicles at entry, verify subscriptions, and log vehicle data — without requiring drivers to present documents manually. With SignMe, a camera at the barrier photographs the car license, the API extracts the plate number and owner data in under 400ms, and the gate controller receives a go/no-go signal before the driver has stopped rolling. The same extracted data populates session logs, billing records, and violation reports. For parking platforms built on Egypt-specific workflows — like ParkMe — SignMe provides the document extraction layer that makes automated vehicle identification possible without a hardware licence-plate reader.

Fleet Management and Compliance

Fleet operators managing dozens or hundreds of vehicles need registration records that are accurate and up to date. Manually re-entering car license data when registration is renewed introduces transcription errors that surface as compliance gaps during government audits. With SignMe, each renewal scan updates the fleet registry automatically — chassis number, engine number, expiry date, and owner details all extracted in a single call. Alerts for approaching expiry dates can be driven directly from the expiry_date field without a secondary verification step.

Security Checkpoints and Access Control

Government facilities, corporate campuses, and residential compounds that operate vehicle-based access control need to verify that the car license matches the visitor record on file. Security personnel scan the car license at the checkpoint, SignMe returns the plate number, owner name, and national ID in under 400ms, and the access control system cross-references against the approved visitor list — with no manual reading, no handwritten logs, and no opportunity for transcription error. For high-throughput checkpoints, see enterprise deployment options.

Accuracy and Performance

Frequently Asked Questions