Carmen Cloud Docs | Carmen Cloud

ABOUT CARMEN CLOUD

A Unified Recognition Ecosystem

Carmen Cloud brings together ANPR, vehicle classification, make & model recognition, and more into one coherent, developer-friendly platform. All APIs, on-prem engines, and mobile clients speak the same JSON — making cloud-to-edge migration seamless.

Read the full architecture overview →

✓ What You Can Build

Tolling systems
Port terminals
Border control
Smart city analytics

Parking automation
Fleet management
Mobile enforcement
Logistics tracking

CHOOSE YOUR PATH

Documentation by Use Case

Find the right docs based on how you'll deploy Carmen Cloud

☁️

Cloud User

Integrate directly with our REST APIs for instant, scalable recognition with no infrastructure to manage.

Vehicle API Docs →Transport API Docs →Cloud Dashboard →

🖥️

On-Prem User

Deploy containerized recognition workers in your own infrastructure for air-gapped or low-latency scenarios.

Carmen Worker →Vehicle Detector →

📱

Mobile User

Build mobile apps that detect, track, and recognize vehicles using the device camera with cloud processing.

Carmen Mobile →

🔧

OEM / Engine User

License our recognition engines for local deployment with cloud-based subscription management.

License Service →

CLOUD DASHBOARD

Manage Workspaces, Keys, Usage and Billing

The Cloud Dashboard is the control center for Carmen Cloud integrations: organize access by workspace, invite teammates, create API keys, manage subscriptions and inspect usage from one place.

Workspaces

A workspace groups subscriptions, credits, API keys, usage data, stored events and hook settings. Users can own workspaces or be invited with role-based permissions.

API Keys

Create multiple keys for different integrations, choose which products each key can access, and set API version or engine parameter overrides per key.

Roles

Owners control the workspace, administrators manage operational settings, and billing users handle subscriptions, credit purchases and invoices.

Operations

Review usage by workspace or API key, enable temporary event storage, configure webhooks and test calls on the built-in demo pages.

Explore Dashboard docs Open Cloud Dashboard

QUICK START

Try the API in Seconds

Select an API and language to see working code examples

Copy & Paste Examples

# Recognize a vehicle's license plate and make/model
curl -X POST 'https://api.carmencloud.com/vehicle/eur' \
  -H 'Accept: application/json' \
  -H 'X-Api-Key: [YOUR_API_KEY]' \
  -H 'Content-Type: multipart/form-data' \
  -F 'service=anpr,mmr' \
  -F 'image=@car.jpg;type=image/jpeg' \
  -F 'location=HUN' \
  -F 'maxreads=1'

// First: npm install --save @adaptive-recognition/carmen-cloud-client

import {
  VehicleAPIClient,
  Locations,
} from "@adaptive-recognition/carmen-cloud-client";

const client = new VehicleAPIClient({
  apiKey: "[YOUR_API_KEY]",
  services: { anpr: true, mmr: true },
  inputImageLocation: Locations.Europe.Hungary,
  cloudServiceRegion: "EU",
});

async function recognizeVehicle() {
  const response = await client.send("./car.jpg");
  console.log(response);
}

recognizeVehicle().catch(err => console.error(err));

# First: pip install carmen-cloud-client

from carmen_cloud_client import (
    VehicleAPIClient,
    VehicleAPIOptions,
    SelectedServices,
    Locations
)

options = VehicleAPIOptions(
    api_key="[YOUR_API_KEY]",
    services=SelectedServices(anpr=True, mmr=True),
    input_image_location=Locations.Europe.Hungary,
    cloud_service_region="EU"
)

client = VehicleAPIClient(options)
response = client.send("./car.jpg")
print(response)

// First: Add dependency to pom.xml:
// <dependency>
//   <groupId>com.adaptiverecognition</groupId>
//   <artifactId>carmen-cloud-client</artifactId>
//   <version>LATEST</version>
// </dependency>

import com.adaptiverecognition.carmencloud.client.vehicle.*;
import java.io.File;

public class VehicleRecognition {
  public static void main(String[] args) throws Exception {
    VehicleAPIClientOptions options =
      VehicleAPIClientOptions.builder()
        .apiKey("[YOUR_API_KEY]")
        .anpr(true)
        .mmr(true)
        .location(Locations.EUROPE_HUNGARY)
        .cloudServiceRegion("EU")
        .build();

    VehicleAPIClient client = new VehicleAPIClient(options);
    VehicleRecognitionResponse response =
      client.send(new File("car.jpg"));
    System.out.println(response);
  }
}

package main

import (
  "fmt"
  "log"
  "os"
  carmencloud "github.com/adaptiverecognition/carmen-cloud-client"
)

func main() {
  client := carmencloud.NewVehicleClient(
    carmencloud.WithAPIKey("[YOUR_API_KEY]"),
    carmencloud.WithServices("anpr", "mmr"),
    carmencloud.WithLocation("HUN"),
    carmencloud.WithRegion("EU"),
  )

  imageFile, err := os.Open("car.jpg")
  if err != nil {
    log.Fatal(err)
  }
  defer imageFile.Close()

  response, err := client.Recognize(imageFile)
  if err != nil {
    log.Fatal(err)
  }
  fmt.Printf("%+v\n", response)
}

#include <curl/curl.h>
#include <fstream>
#include <iostream>

size_t WriteCallback(void* contents, size_t size,
                     size_t nmemb, std::string* userp) {
  userp->append((char*)contents, size * nmemb);
  return size * nmemb;
}

int main() {
  CURL* curl = curl_easy_init();
  if (!curl) return 1;

  std::ifstream imageFile("car.jpg", std::ios::binary);
  std::string response;

  curl_easy_setopt(curl, CURLOPT_URL,
    "https://api.carmencloud.com/vehicle/eur");
  curl_easy_setopt(curl, CURLOPT_POST, 1L);

  struct curl_slist* headers = NULL;
  headers = curl_slist_append(headers,
    "X-Api-Key: [YOUR_API_KEY]");
  curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);

  curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION,
    WriteCallback);
  curl_easy_setopt(curl, CURLOPT_WRITEDATA, &response);
  curl_easy_setopt(curl, CURLOPT_UPLOAD, 1L);

  CURLcode res = curl_easy_perform(curl);
  if (res != CURLE_OK) {
    std::cerr << curl_easy_strerror(res) << std::endl;
  }

  std::cout << response << std::endl;
  curl_slist_free_all(headers);
  curl_easy_cleanup(curl);
  return 0;
}

LEARN BY DOING

Tutorials

Step-by-step guides to get you from zero to production

GETTING STARTED

Detect a Vehicle

Learn how to read license plates and identify vehicle make, model, and color from images using the Vehicle API.

⏱️ 10 minVehicle API

GETTING STARTED

Read a Container Code

Extract ISO container codes, rail wagon IDs, and trailer numbers from logistics imagery with the Transport API.

⏱️ 8 minTransport API

INTEGRATION

Store and Forward Results

Configure webhooks to receive recognition results asynchronously and integrate with your event-driven backend.

⏱️ 15 minWebhooks

TECHNICAL REFERENCE

General Reference

Detailed specifications and lookup tables

🌍

Carmen Recognition Packages

Choose a monthly lookup package, buy prepaid Vehicle API credits, or contact sales for larger custom volumes.

Micro

25klookups/month

For pilots, low-volume services and early production deployments.

Vehicle API access
Transportation & Cargo API access
Workspace usage reporting
Overage handling when enabled

Get Started

Production

Starter / Growth

100k-250klookups/month

For production systems with predictable monthly traffic.

Starter: 100,000 lookups/month
Growth: 250,000 lookups/month
Storage & Hooks workflows
API-key-level usage analysis

Choose Package

Professional

500klookups/month

For larger monthly workloads and mature integrations.

500,000 lookups/month
Vehicle and Transport APIs
Workspace billing controls
Regional Stripe billing account

Get Started

Prepaid Vehicle API Credits

1klookups/unit

For customers who are not ready for a monthly Vehicle API subscription.

Minimum purchase: 10 units
Purchase range: 10-999 units
Credits remain available until used
Consumed only when no active subscription covers the request

Buy Credits

Custom Volume

Custompackage

For deployments above the Professional package or with custom commercial requirements.

Packages above 500,000 lookups/month
Project-specific commercial terms
EU/global and US billing regions
Sales-assisted onboarding

Contact Sales

HAVE QUESTIONS?

Frequently Asked Questions

Find answers to common questions

/Resources

Mobile App for ANPR & MMR

Carmen Cloud Subscription Required

/Use Cases

/Company

Build Intelligent Recognition Systems

A Unified Recognition Ecosystem

✓ What You Can Build

Documentation by Use Case

Cloud User

On-Prem User

Mobile User

OEM / Engine User

Manage Workspaces, Keys, Usage and Billing

Workspaces

API Keys

Roles

Operations

Try the API in Seconds

Tutorials

Detect a Vehicle

Read a Container Code

Store and Forward Results

General Reference

Regions & Locations

Transport Code Types

Error Codes

API Changelog

Carmen Recognition Packages

Micro

Starter / Growth

Professional

Prepaid Vehicle API Credits

Custom Volume

Frequently Asked Questions

General

Social

Legal

Cloud Dashboard

Downloadable Products

Tutorials

General Reference

API Reference

Library Reference

Copyright © 2026 Adaptive Recognition.