deep-license-plate-recognition: Python Clients and Utilities for the Plate Recognizer API

What This Repository Is and What It Does Not Contain

The README's first sentence is explicit: "This repository contains example clients, integrations, and operational utilities for Plate Recognizer Snapshot, Stream, Blur, and ParkPow. It does not contain the recognition models themselves."

Plate Recognizer is a commercial ALPR service with two deployment modes: a cloud API (Snapshot) and a self-hosted SDK that runs the recognition engine in a local container. The scripts in this repository are client-side tools that send images to one of those engines and process the results. Most scripts accept either an --api-key for the cloud service or an --sdk-url for a local deployment, making it straightforward to switch between the two.

The primary language listed is C++, which reflects the language examples in the cpp/ directory, but the main scripts are Python. Python 3.10 or newer is required. A development environment is managed with uv.

Repository Map: Tools for Each Workflow

The repository's README provides a table mapping use cases to scripts and directories. The key tools are:

- plate_recognition.py: single-image or batch recognition against the cloud API or a self-hosted SDK. - number_plate_redaction.py: detect and blur plates in images, with options for high-resolution splitting and regex-based ignore rules. - ftp_and_sftp_processor.py: pull images from an FTP or SFTP server and recognize them. - transfer.py: watch a directory, recognize new images, and optionally forward results to ParkPow. - stream/: utilities for Plate Recognizer Stream (video). - webhooks/: webhook consumer integrations. - parkpow/: integrations for ParkPow camera systems. - blur/ and video-editor/: utilities for the Blur product. - docker/: tools for installing and managing on-premise SDKs. - benchmark/: scripts for performance testing. - cpp/, csharp/, java/: example clients in other languages.

The README notes that each subproject has its own dependencies. The shared root environment (managed with uv) covers the main Python scripts; subdirectory tools should be installed following their own READMEs.

Recognizing a License Plate from an Image

Clone the repository and install the two dependencies for the image client:

git clone https://github.com/parkpow/deep-license-plate-recognition.git
cd deep-license-plate-recognition
python -m venv .venv
source .venv/bin/activate
python -m pip install requests pillow

Run recognition against the cloud API:

python plate_recognition.py --api-key MY_API_KEY /path/to/vehicle.jpg

To use a running self-hosted Snapshot SDK instead:

python plate_recognition.py --sdk-url http://localhost:8080 /path/to/vehicle.jpg

The command returns JSON with the recognized plate text, a confidence score (score), a detection score (dscore), and a bounding box (xmin, ymin, ymax, xmax). The README documents a sample response showing a plate field alongside the box coordinates, score, and dscore values, and a filename field at the outer level. Full schema details are in the Snapshot API reference linked from the README.

To limit recognition to specific regions and improve accuracy, add --regions flags:

python plate_recognition.py --api-key MY_API_KEY --regions fr --regions it /path/to/car.jpg

Run python plate_recognition.py --help for the complete list of output, annotation, cropping, and engine options.

Plate Redaction for Privacy Workflows

number_plate_redaction.py detects plates and saves blurred copies of images, which is useful for publishing dashcam footage or surveillance stills where plates must be obscured under privacy regulations.

python number_plate_redaction.py --api-key MY_API_KEY vehicle.jpg --save-blurred

The script includes options for high-resolution images (--split-image, which uses three API calls), regex-based plate filtering (--ignore-regexp REGEX to leave plates matching a pattern unblurred), and bounding box filtering (--ignore-no-bb to ignore results without a vehicle bounding box). A self-hosted SDK can be used in place of the cloud API with --sdk-url.

The README notes that the script is effective on small or barely readable plates, not just clear, well-lit captures. Run python number_plate_redaction.py --help for the full CLI reference.

FTP Processing and Directory Watching

For environments where a camera uploads images to an FTP or SFTP server, ftp_and_sftp_processor.py pulls those images and passes them to the recognition engine:

python -m pip install requests pillow paramiko
python ftp_and_sftp_processor.py \
  --api-key MY_API_KEY \
  --hostname FTP_HOST_NAME \
  --ftp-user FTP_USER \
  --ftp-password FTP_PASSWORD \
  --folder /path/to/server_folder

Add --protocol sftp to use SFTP. The --delete option removes processed remote files, so the README recommends testing without it first. For ongoing monitoring, transfer.py watches a local directory for new images, runs recognition on each arrival, moves processed files to an archive folder, and can optionally forward results to ParkPow.

The development setup uses uv. Install uv, then create the root development environment:

uv sync --locked

Run tools in that environment with uv run.

Cloud API vs. Self-Hosted SDK: The Practical Trade-Off

The cloud API (Snapshot) is the lowest-friction option: it requires only an API key from app.platerecognizer.com and a network connection from the client. The trade-off is that every image leaves the local network, which may conflict with privacy requirements in healthcare, law enforcement, or government environments.

The self-hosted Snapshot SDK runs the recognition engine locally. The docker/ directory in the repository provides tools for installing and managing that on-premise deployment. The README does not document the SDK installation steps directly, pointing instead to the on-premise tools README in docker/.

Neither option is free for production use: Plate Recognizer is a commercial service. The repository itself is MIT-licensed, but using it productively requires a Plate Recognizer account. The API token must not be committed to version control; the README explicitly notes to replace MY_API_KEY locally and not commit the token.

Alternative: OpenALPR and Rekor Scout

OpenALPR (now distributed under Rekor Scout) is an open-source ALPR library with a C++ core and Python bindings. It runs recognition entirely on-premise without a cloud API call, which removes the per-recognition cost and the requirement for network access. OpenALPR uses the Tesseract OCR engine and a trained neural network for plate detection.

The practical difference is completeness versus control. Plate Recognizer (and by extension this repository) provides a managed accuracy layer: NVIDIA GPU-accelerated recognition, region-specific models for country-specific plate formats, and a maintained API. OpenALPR puts the model and infrastructure management burden on the deployer but removes the recurring service dependency. For a deployment that processes millions of plates per day and needs to contain costs, the trade-off between the two is significant.

Editorial conclusion

This repository is the right starting point for any workflow built around Plate Recognizer's Snapshot, Stream, Blur, or ParkPow services. It covers the most common integration patterns: cloud API calls, self-hosted SDK calls, batch processing from a directory or FTP server, directory watching, plate redaction, and webhook consumers. It is not a standalone ALPR library; the actual recognition runs in Plate Recognizer's engine, which requires an API token or a running self-hosted SDK. Before using it, obtain a token from app.platerecognizer.com and confirm whether the images you process fall under Plate Recognizer's usage terms for your plan.

Frequently asked questions

Official sources

1. Issues
2. License: MIT
3. parkpow/deep-license-plate-recognition on GitHub
4. Project website
5. README