Reconocimiento de matrículas y vehículos - Documentación para desarrolladores de Rhombus

Nota

Esta página se tradujo automáticamente. Si encuentras errores o tienes sugerencias, escríbenos.

Descripción general

Las cámaras Rhombus con reconocimiento de matrículas (LPR) detectan vehículos y leen sus matrículas a medida que pasan por una escena. Cada detección se convierte en un evento de vehículo que registra la placa, la cámara y la ubicación que la reportan, una imagen capturada y la hora en que fue vista.

A través de la API, puedes:

Consultar eventos de detección en toda tu organización, filtrados por dispositivo, ubicación, placa, nombre o etiqueta
Buscar una placa específica con coincidencia exacta o aproximada para encontrar cada vez que fue vista
Crear una lista de vigilancia de vehículos guardados ("placas de interés") con indicadores de alerta y confianza, nombres y etiquetas
Generar informes por dispositivo que agrupan las detecciones por hora, día, semana o mes
Exportar eventos de vehículos como CSV para análisis externo o registro

Nota

Cada marca de tiempo de evento de vehículo se reporta en milisegundos de época (epoch), pero el nombre del campo difiere según el endpoint (startTimeMs, startTime, timestampMs, createdAtMillis, eventTimestamp). Cada sección a continuación indica el campo exacto que debes usar. No existe un campo de región, estado ni una puntuación de confianza numérica en los eventos de vehículos; no esperes ninguno.

Requisitos previos

Nota

Antes de comenzar, asegúrate de tener:

Una clave de API de Rhombus con acceso de lectura a cámaras (generada en la Consola de Rhombus en Configuración → Integraciones y recursos para desarrolladores → Tokens de API). Reportar una lectura incorrecta requiere además el permiso MANAGE_LICENSEPLATES, y la exportación CSV requiere el permiso REPORT_ADMINISTRATION.
Al menos una cámara compatible con LPR desplegada y leyendo placas en una ubicación
El UUID del dispositivo de esa cámara, que puedes obtener de los endpoints de cámara o de la Consola de Rhombus

Todas las solicitudes son POST a https://api2.rhombussystems.com y se autentican con los encabezados x-auth-scheme y x-auth-apikey que se muestran en cada ejemplo.

Flujo 1: Consultar detecciones recientes

Usa getVehicleEvents para recuperar eventos de detección en toda tu organización. Este es el endpoint principal para llevar la actividad de LPR a un panel o informe.

La solicitud combina dos tipos de criterios que se comportan de manera diferente:

Los campos de filtro (deviceUuidFilter, locationUuidFilter) se combinan con Y (AND): un evento devuelto debe satisfacer todos los filtros que proporciones.
Los campos de consulta (nameQuery, licensePlateExactQuery, vehicleLabelQuery, licensePlateFuzzyQuery, unnamedQuery) se combinan con O (OR): un evento devuelto debe satisfacer al menos una de las consultas que proporciones.

import requests
import time

headers = {
    "x-auth-scheme": "api-token",
    "x-auth-apikey": "YOUR_API_KEY",
    "Content-Type": "application/json"
}

# Consultar las detecciones de las últimas 24 horas de una cámara
now_ms = int(time.time() * 1000)
one_day_ago_ms = now_ms - (24 * 60 * 60 * 1000)

response = requests.post(
    "https://api2.rhombussystems.com/api/vehicle/getVehicleEvents",
    headers=headers,
    json={
        "startTimeMs": one_day_ago_ms,
        "endTimeMs": now_ms,
        "deviceUuidFilter": ["YOUR_CAMERA_UUID"]
    }
)

data = response.json()
for event in data.get("events", []):
    plate = event.get("vehicleLicensePlate")
    ts = event.get("eventTimestamp")
    device = event.get("deviceUuid")
    print(f"[{ts}] {plate} vista por {device}")

const now = Date.now();
const oneDayAgo = now - (24 * 60 * 60 * 1000);

const response = await fetch('https://api2.rhombussystems.com/api/vehicle/getVehicleEvents', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'x-auth-scheme': 'api-token',
    'x-auth-apikey': 'YOUR_API_KEY'
  },
  body: JSON.stringify({
    startTimeMs: oneDayAgo,
    endTimeMs: now,
    deviceUuidFilter: ['YOUR_CAMERA_UUID']
  })
});

const data = await response.json();
for (const event of data.events || []) {
  console.log(`[${new Date(event.eventTimestamp).toISOString()}] ${event.vehicleLicensePlate} vista por ${event.deviceUuid}`);
}

curl -X POST https://api2.rhombussystems.com/api/vehicle/getVehicleEvents \
  -H "Content-Type: application/json" \
  -H "x-auth-scheme: api-token" \
  -H "x-auth-apikey: YOUR_API_KEY" \
  -d '{
    "startTimeMs": 1712620800000,
    "endTimeMs": 1712707200000,
    "deviceUuidFilter": ["YOUR_CAMERA_UUID"]
  }'

Campos de solicitud

startTimeMsintegerbody

Inicio de la ventana de tiempo (más antiguo) en milisegundos de época.

endTimeMsintegerbody

Fin de la ventana de tiempo (más reciente) en milisegundos de época.

deviceUuidFilterstring[]body

Devuelve solo eventos de estos UUID de cámara. Se combina con Y (AND) con otros filtros.

locationUuidFilterstring[]body

Devuelve solo eventos de estos UUID de ubicación. Se combina con Y (AND) con otros filtros.

nameQuerystring[]body

Devuelve eventos cuyo nombre de vehículo coincida con uno de estos valores. Se combina con O (OR) con otras consultas.

licensePlateExactQuerystring[]body

Devuelve eventos cuya placa coincida exactamente con uno de estos valores. Se combina con O (OR) con otras consultas.

vehicleLabelQuerystring[]body

Devuelve eventos etiquetados con una de estas etiquetas de vehículo. Se combina con O (OR) con otras consultas.

licensePlateFuzzyQuerystringbody

Devuelve eventos cuya placa coincida aproximadamente con esta placa parcial o completa, tolerando lecturas incorrectas de caracteres. Se combina con O (OR) con otras consultas.

unnamedQuerybooleanbody

Si es false, devuelve solo eventos que tienen un nombre; si es true, devuelve solo eventos sin nombre. Omítelo si no lo necesitas. Se combina con O (OR) con otras consultas.

Campos de respuesta

La respuesta contiene un arreglo events. Cada evento tiene estos campos:

uuidstring

Identificador único del evento de vehículo.

orgUuidstring

Organización a la que pertenece el evento.

deviceUuidstring

UUID de la cámara que reportó la detección.

locationUuidstring

Ubicación donde ocurrió la detección.

vehicleLicensePlatestring

La cadena de matrícula reconocida.

matchingLicensePlatesstring[]

Cadenas de placa consideradas coincidencias completas para esta detección.

partialLicensePlatesstring[]

Cadenas de placa consideradas coincidencias parciales para esta detección.

imageS3Keystring

Clave S3 de la imagen completa de la detección. Es una clave de almacenamiento, no una URL.

thumbnailS3Keystring

Clave S3 de la miniatura de la detección. Es una clave de almacenamiento, no una URL.

eventTimestampinteger

Cuándo ocurrió la detección, en milisegundos de época.

namestring

Nombre del vehículo, si la placa está asociada a un vehículo guardado.

Advertencia

imageS3Key y thumbnailS3Key son claves de almacenamiento S3, no URL de imágenes visualizables directamente. Usa los endpoints de medios y grabaciones para recuperar los bytes de la imagen.

Nota

Los endpoints getRecentVehicleEvents, getRecentVehicleEventsByLocation y getRecentVehicleEventsForVehicle son heredados (legacy). Prefiere getVehicleEvents para nuevas integraciones: su modelo de filtros/consultas los reemplaza.

Flujo 2: Buscar una placa con coincidencia aproximada

Cuando tengas una placa específica que rastrear, searchLicensePlates encuentra cada evento que coincide con ella. Habilita fuzzy para tolerar lecturas incorrectas de caracteres, útil cuando una placa está parcialmente obstruida o la lectura original fue imperfecta.

import requests
import time

headers = {
    "x-auth-scheme": "api-token",
    "x-auth-apikey": "YOUR_API_KEY",
    "Content-Type": "application/json"
}

now_ms = int(time.time() * 1000)
one_week_ago_ms = now_ms - (7 * 24 * 60 * 60 * 1000)

response = requests.post(
    "https://api2.rhombussystems.com/api/search/searchLicensePlates",
    headers=headers,
    json={
        "licensePlate": "ABC123",
        "startTime": one_week_ago_ms,
        "endTime": now_ms,
        "fuzzy": True
    }
)

data = response.json()
for hit in data.get("vehicleEvents", []):
    plate = hit.get("vehicleLicensePlate")
    matched = hit.get("searchMatchedTerm")
    match_type = hit.get("searchMatchedType")
    print(f"{plate} coincidió con '{matched}' ({match_type}) a las {hit.get('eventTimestamp')}")

const now = Date.now();
const oneWeekAgo = now - (7 * 24 * 60 * 60 * 1000);

const response = await fetch('https://api2.rhombussystems.com/api/search/searchLicensePlates', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'x-auth-scheme': 'api-token',
    'x-auth-apikey': 'YOUR_API_KEY'
  },
  body: JSON.stringify({
    licensePlate: 'ABC123',
    startTime: oneWeekAgo,
    endTime: now,
    fuzzy: true
  })
});

const data = await response.json();
for (const hit of data.vehicleEvents || []) {
  console.log(`${hit.vehicleLicensePlate} coincidió con '${hit.searchMatchedTerm}' (${hit.searchMatchedType})`);
}

curl -X POST https://api2.rhombussystems.com/api/search/searchLicensePlates \
  -H "Content-Type: application/json" \
  -H "x-auth-scheme: api-token" \
  -H "x-auth-apikey: YOUR_API_KEY" \
  -d '{
    "licensePlate": "ABC123",
    "startTime": 1712102400000,
    "endTime": 1712707200000,
    "fuzzy": true
  }'

Campos de solicitud

licensePlatestringbodyobligatorio

El número de placa que se busca.

startTimeintegerbody

Inicio de la ventana de búsqueda en milisegundos de época. Ten en cuenta que el campo se llama startTime, no startTimeMs.

endTimeintegerbody

Fin de la ventana de búsqueda en milisegundos de época.

deviceUuidsstring[]body

Limita la búsqueda a estos UUID de cámara.

fuzzybooleanbody

Cuando es true, permite la coincidencia aproximada para caracteres leídos incorrectamente.

Advertencia

El campo forcedFuzziness está obsoleto. Usa el indicador booleano fuzzy en su lugar.

Campos de respuesta

El arreglo vehicleEvents contiene todos los campos de evento de vehículo del Flujo 1, más dos campos específicos de la búsqueda:

searchMatchedTermstring

El término de placa que coincidió con tu consulta.

searchMatchedTypestring

Cómo se realizó la coincidencia (por ejemplo, exacta frente a aproximada).

Flujo 3: Crear una lista de vigilancia de vehículos guardados

Un vehículo guardado es una "placa de interés" que deseas rastrear. Cada vehículo guardado lleva un indicador alert (notificar cuando se ve) y un indicador trust (tratar como conocido/seguro), además de un nombre, una descripción y etiquetas opcionales. Guardar un vehículo también permite que Rhombus adjunte el name a los futuros eventos de detección de esa placa.

Guardar un vehículo

import requests
import time

headers = {
    "x-auth-scheme": "api-token",
    "x-auth-apikey": "YOUR_API_KEY",
    "Content-Type": "application/json"
}

response = requests.post(
    "https://api2.rhombussystems.com/api/vehicle/saveVehicle",
    headers=headers,
    json={
        "vehicleLicensePlate": "ABC123",
        "createdAtMillis": int(time.time() * 1000),
        "name": "Furgoneta de reparto",
        "description": "Ford Transit blanca - proveedor aprobado",
        "alert": True,
        "trust": True
    }
)

print(response.json())

const response = await fetch('https://api2.rhombussystems.com/api/vehicle/saveVehicle', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'x-auth-scheme': 'api-token',
    'x-auth-apikey': 'YOUR_API_KEY'
  },
  body: JSON.stringify({
    vehicleLicensePlate: 'ABC123',
    createdAtMillis: Date.now(),
    name: 'Furgoneta de reparto',
    description: 'Ford Transit blanca - proveedor aprobado',
    alert: true,
    trust: true
  })
});

console.log(await response.json());

curl -X POST https://api2.rhombussystems.com/api/vehicle/saveVehicle \
  -H "Content-Type: application/json" \
  -H "x-auth-scheme: api-token" \
  -H "x-auth-apikey: YOUR_API_KEY" \
  -d '{
    "vehicleLicensePlate": "ABC123",
    "createdAtMillis": 1712707200000,
    "name": "Furgoneta de reparto",
    "description": "Ford Transit blanca - proveedor aprobado",
    "alert": true,
    "trust": true
  }'

vehicleLicensePlatestringbodyobligatorio

La placa que identifica a este vehículo guardado.

createdAtMillisintegerbody

Marca de tiempo de creación en milisegundos de época.

alertbooleanbody

Si se debe generar una alerta cuando se detecta este vehículo.

trustbooleanbody

Si este vehículo es de confianza (conocido/seguro).

namestringbody

Nombre para mostrar del vehículo.

descriptionstringbody

Descripción de texto libre.

thumbnailS3Keystringbody

Clave S3 de una imagen en miniatura del vehículo.

Listar vehículos guardados

Recupera todos los vehículos guardados de tu organización. El cuerpo de la solicitud está vacío.

import requests

headers = {
    "x-auth-scheme": "api-token",
    "x-auth-apikey": "YOUR_API_KEY",
    "Content-Type": "application/json"
}

response = requests.post(
    "https://api2.rhombussystems.com/api/vehicle/getVehicles",
    headers=headers,
    json={}
)

data = response.json()
for vehicle in data.get("vehicles", []):
    print(f"{vehicle.get('licensePlate')}: {vehicle.get('name')} "
          f"(alert={vehicle.get('alert')}, trust={vehicle.get('trust')})")

const response = await fetch('https://api2.rhombussystems.com/api/vehicle/getVehicles', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'x-auth-scheme': 'api-token',
    'x-auth-apikey': 'YOUR_API_KEY'
  },
  body: JSON.stringify({})
});

const data = await response.json();
for (const vehicle of data.vehicles || []) {
  console.log(`${vehicle.licensePlate}: ${vehicle.name} (alert=${vehicle.alert}, trust=${vehicle.trust})`);
}

curl -X POST https://api2.rhombussystems.com/api/vehicle/getVehicles \
  -H "Content-Type: application/json" \
  -H "x-auth-scheme: api-token" \
  -H "x-auth-apikey: YOUR_API_KEY" \
  -d '{}'

Cada entrada del arreglo vehicles es un vehículo guardado:

licensePlatestring

La placa que identifica al vehículo guardado.

orgUuidstring

Organización a la que pertenece el vehículo.

createdAtMillisinteger

Cuándo se guardó el vehículo, en milisegundos de época.

alertboolean

Si las detecciones generan una alerta.

trustboolean

Si el vehículo es de confianza.

namestring

Nombre para mostrar.

descriptionstring

Descripción de texto libre.

thumbnailS3Keystring

Clave S3 de la miniatura del vehículo.

Agregar y quitar etiquetas

Las etiquetas agrupan los vehículos guardados en categorías como "empleado", "proveedor" o "marcado". Agrega una etiqueta a una placa con addVehicleLabel y quítala con removeVehicleLabel.

import requests

headers = {
    "x-auth-scheme": "api-token",
    "x-auth-apikey": "YOUR_API_KEY",
    "Content-Type": "application/json"
}

response = requests.post(
    "https://api2.rhombussystems.com/api/vehicle/addVehicleLabel",
    headers=headers,
    json={
        "vehicleLicensePlate": "ABC123",
        "label": "Proveedor aprobado"
    }
)

print(response.json())

const response = await fetch('https://api2.rhombussystems.com/api/vehicle/addVehicleLabel', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'x-auth-scheme': 'api-token',
    'x-auth-apikey': 'YOUR_API_KEY'
  },
  body: JSON.stringify({
    vehicleLicensePlate: 'ABC123',
    label: 'Proveedor aprobado'
  })
});

console.log(await response.json());

curl -X POST https://api2.rhombussystems.com/api/vehicle/addVehicleLabel \
  -H "Content-Type: application/json" \
  -H "x-auth-scheme: api-token" \
  -H "x-auth-apikey: YOUR_API_KEY" \
  -d '{
    "vehicleLicensePlate": "ABC123",
    "label": "Proveedor aprobado"
  }'

Para ver todas las etiquetas asignadas en tu organización, llama a getVehicleLabelsForOrg. Su respuesta contiene un mapa vehicleLabels indexado por matrícula, donde cada valor es el conjunto de etiquetas de esa placa.

import requests

headers = {
    "x-auth-scheme": "api-token",
    "x-auth-apikey": "YOUR_API_KEY",
    "Content-Type": "application/json"
}

response = requests.post(
    "https://api2.rhombussystems.com/api/vehicle/getVehicleLabelsForOrg",
    headers=headers,
    json={}
)

labels = response.json().get("vehicleLabels", {})
for plate, plate_labels in labels.items():
    print(f"{plate}: {', '.join(plate_labels)}")

const response = await fetch('https://api2.rhombussystems.com/api/vehicle/getVehicleLabelsForOrg', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'x-auth-scheme': 'api-token',
    'x-auth-apikey': 'YOUR_API_KEY'
  },
  body: JSON.stringify({})
});

const data = await response.json();
for (const [plate, plateLabels] of Object.entries(data.vehicleLabels || {})) {
  console.log(`${plate}: ${plateLabels.join(', ')}`);
}

curl -X POST https://api2.rhombussystems.com/api/vehicle/getVehicleLabelsForOrg \
  -H "Content-Type: application/json" \
  -H "x-auth-scheme: api-token" \
  -H "x-auth-apikey: YOUR_API_KEY" \
  -d '{}'

Asociar eventos anteriores con un vehículo guardado

Si una placa fue detectada antes de que la guardaras como vehículo, usa associateEventsToVehicle para adjuntar esos eventos de detección históricos al vehículo guardado. Pasa los UUID de los eventos (del Flujo 1 o 2) y la placa.

import requests

headers = {
    "x-auth-scheme": "api-token",
    "x-auth-apikey": "YOUR_API_KEY",
    "Content-Type": "application/json"
}

response = requests.post(
    "https://api2.rhombussystems.com/api/vehicle/associateEventsToVehicle",
    headers=headers,
    json={
        "vehicleLicensePlate": "ABC123",
        "eventUuids": ["EVENT_UUID_1", "EVENT_UUID_2"]
    }
)

print(response.json())

const response = await fetch('https://api2.rhombussystems.com/api/vehicle/associateEventsToVehicle', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'x-auth-scheme': 'api-token',
    'x-auth-apikey': 'YOUR_API_KEY'
  },
  body: JSON.stringify({
    vehicleLicensePlate: 'ABC123',
    eventUuids: ['EVENT_UUID_1', 'EVENT_UUID_2']
  })
});

console.log(await response.json());

curl -X POST https://api2.rhombussystems.com/api/vehicle/associateEventsToVehicle \
  -H "Content-Type: application/json" \
  -H "x-auth-scheme: api-token" \
  -H "x-auth-apikey: YOUR_API_KEY" \
  -d '{
    "vehicleLicensePlate": "ABC123",
    "eventUuids": ["EVENT_UUID_1", "EVENT_UUID_2"]
  }'

Eliminar un vehículo guardado

Quita un vehículo de tu lista de vigilancia por su placa.

import requests

headers = {
    "x-auth-scheme": "api-token",
    "x-auth-apikey": "YOUR_API_KEY",
    "Content-Type": "application/json"
}

response = requests.post(
    "https://api2.rhombussystems.com/api/vehicle/deleteVehicle",
    headers=headers,
    json={
        "vehicleLicensePlate": "ABC123"
    }
)

print(response.json())

const response = await fetch('https://api2.rhombussystems.com/api/vehicle/deleteVehicle', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'x-auth-scheme': 'api-token',
    'x-auth-apikey': 'YOUR_API_KEY'
  },
  body: JSON.stringify({
    vehicleLicensePlate: 'ABC123'
  })
});

console.log(await response.json());

curl -X POST https://api2.rhombussystems.com/api/vehicle/deleteVehicle \
  -H "Content-Type: application/json" \
  -H "x-auth-scheme: api-token" \
  -H "x-auth-apikey: YOUR_API_KEY" \
  -d '{"vehicleLicensePlate": "ABC123"}'

Consejo

Cuando una detección se lee mal o se atribuye a la placa equivocada, repórtala con reportVehicleEvent (pasando el eventUuid del evento). Esta retroalimentación ayuda a mejorar la precisión del reconocimiento. Reportar requiere el permiso MANAGE_LICENSEPLATES en tu clave de API.

Flujo 4: Informes por dispositivo y exportación CSV

Informe por dispositivo

getLicensePlatesByDevice devuelve las detecciones de matrículas de una sola cámara, agrupadas por un intervalo de informe. Proporciona la hora de referencia como timestampMs (milisegundos de época) y elige un interval.

import requests
import time

headers = {
    "x-auth-scheme": "api-token",
    "x-auth-apikey": "YOUR_API_KEY",
    "Content-Type": "application/json"
}

response = requests.post(
    "https://api2.rhombussystems.com/api/report/getLicensePlatesByDevice",
    headers=headers,
    json={
        "deviceUuid": "YOUR_CAMERA_UUID",
        "timestampMs": int(time.time() * 1000),
        "interval": "DAILY"
    }
)

data = response.json()
for event in data.get("licensePlateEvents", []):
    print(f"{event.get('vehicleLicensePlate')} a las {event.get('eventTimestamp')}")

const response = await fetch('https://api2.rhombussystems.com/api/report/getLicensePlatesByDevice', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'x-auth-scheme': 'api-token',
    'x-auth-apikey': 'YOUR_API_KEY'
  },
  body: JSON.stringify({
    deviceUuid: 'YOUR_CAMERA_UUID',
    timestampMs: Date.now(),
    interval: 'DAILY'
  })
});

const data = await response.json();
for (const event of data.licensePlateEvents || []) {
  console.log(`${event.vehicleLicensePlate} a las ${event.eventTimestamp}`);
}

curl -X POST https://api2.rhombussystems.com/api/report/getLicensePlatesByDevice \
  -H "Content-Type: application/json" \
  -H "x-auth-scheme: api-token" \
  -H "x-auth-apikey: YOUR_API_KEY" \
  -d '{
    "deviceUuid": "YOUR_CAMERA_UUID",
    "timestampMs": 1712707200000,
    "interval": "DAILY"
  }'

deviceUuidstringbodyobligatorio

El UUID de cámara sobre el que se genera el informe.

timestampMsintegerbody

Hora de referencia para el informe, como marca de tiempo UNIX en milisegundos.

intervalstringbodyobligatorio

Agrupación del informe. Uno de HOURLY, DAILY, WEEKLY o MONTHLY.

Advertencia

El campo dateLocal está obsoleto. Usa timestampMs en su lugar.

El arreglo licensePlateEvents de la respuesta usa los mismos campos de evento de vehículo descritos en el Flujo 1.

Exportar a CSV

export/vehicleEventsV2 transmite los eventos de vehículos coincidentes como CSV. Acepta el mismo cuerpo de solicitud que getVehicleEvents (Flujo 1) —los campos de filtro y consulta, combinados con Y (AND) y O (OR) de la misma manera— y devuelve text/csv directamente en el cuerpo de la respuesta en lugar de JSON. Este endpoint requiere el permiso REPORT_ADMINISTRATION.

import requests
import time

headers = {
    "x-auth-scheme": "api-token",
    "x-auth-apikey": "YOUR_API_KEY",
    "Content-Type": "application/json"
}

now_ms = int(time.time() * 1000)
thirty_days_ago_ms = now_ms - (30 * 24 * 60 * 60 * 1000)

response = requests.post(
    "https://api2.rhombussystems.com/api/export/vehicleEventsV2",
    headers=headers,
    json={
        "startTimeMs": thirty_days_ago_ms,
        "endTimeMs": now_ms,
        "deviceUuidFilter": ["YOUR_CAMERA_UUID"]
    }
)

with open("vehicle_events.csv", "w") as f:
    f.write(response.text)
print("Eventos de vehículos exportados a vehicle_events.csv")

const now = Date.now();
const thirtyDaysAgo = now - (30 * 24 * 60 * 60 * 1000);

const response = await fetch('https://api2.rhombussystems.com/api/export/vehicleEventsV2', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'x-auth-scheme': 'api-token',
    'x-auth-apikey': 'YOUR_API_KEY'
  },
  body: JSON.stringify({
    startTimeMs: thirtyDaysAgo,
    endTimeMs: now,
    deviceUuidFilter: ['YOUR_CAMERA_UUID']
  })
});

// La respuesta es texto CSV, no JSON
const csvData = await response.text();
console.log(csvData);

curl -X POST https://api2.rhombussystems.com/api/export/vehicleEventsV2 \
  -H "Content-Type: application/json" \
  -H "x-auth-scheme: api-token" \
  -H "x-auth-apikey: YOUR_API_KEY" \
  -d '{
    "startTimeMs": 1710115200000,
    "endTimeMs": 1712707200000,
    "deviceUuidFilter": ["YOUR_CAMERA_UUID"]
  }' \
  -o vehicle_events.csv

Nota

export/vehicleEventsV2 reemplaza al endpoint anterior export/vehicleEvents, que está obsoleto. Usa V2 para nuevas integraciones: acepta el modelo de filtros/consultas más completo de getVehicleEvents.

Casos de uso

Seguimiento de flotas y proveedores

Guarda las placas de tu flota y de proveedores aprobados con el indicador trust y luego concílialas con los eventos de detección para confirmar llegadas puntuales.

Alertas de lista de vigilancia

Guarda las placas de interés con alert: true y combina las detecciones con webhooks para notificar a seguridad cuando se ve un vehículo marcado.

Análisis de estacionamiento y acceso

Usa los informes por dispositivo para contar el tráfico diario o semanal de vehículos en una puerta o entrada de estacionamiento.

Investigación y auditoría

Busca de forma aproximada una placa parcial de un incidente y luego exporta los eventos coincidentes como CSV para un informe.

Solución de problemas

Mi filtro de tiempo no devuelve eventos

Confirma que estás enviando milisegundos de época, no segundos, y que usas el nombre de campo correcto para el endpoint: startTimeMs/endTimeMs para getVehicleEvents y export/vehicleEventsV2, startTime/endTime para searchLicensePlates, y timestampMs para getLicensePlatesByDevice. Un valor en segundos se resolverá en 1970 y no devolverá nada.

Una placa que sé que fue vista no aparece en los resultados de búsqueda

Las lecturas de LPR pueden variar según la iluminación, el ángulo y la velocidad. Establece fuzzy: true en searchLicensePlates para tolerar lecturas incorrectas de caracteres, y revisa matchingLicensePlates y partialLicensePlates en los eventos devueltos para detectar coincidencias cercanas.

getVehicleEvents devuelve más de lo que esperaba

Recuerda que los campos de consulta (nameQuery, licensePlateExactQuery, vehicleLabelQuery, licensePlateFuzzyQuery, unnamedQuery) se combinan con O (OR): un evento solo tiene que coincidir con uno de ellos. Los campos de filtro (deviceUuidFilter, locationUuidFilter) se combinan con Y (AND). Reduce los resultados moviendo criterios a los filtros o disminuyendo la cantidad de consultas.

No puedo ver la imagen de imageS3Key

imageS3Key y thumbnailS3Key son claves de almacenamiento S3, no URL que puedas abrir directamente. Usa los endpoints de medios y grabaciones de Rhombus para obtener el contenido de la imagen de una clave dada.

reportVehicleEvent devuelve un error de permiso

Reportar una lectura incorrecta requiere el permiso MANAGE_LICENSEPLATES en tu clave de API. La exportación CSV requiere REPORT_ADMINISTRATION. Genera o actualiza tu clave con los permisos necesarios en la Consola de Rhombus en Configuración → Integraciones y recursos para desarrolladores → Tokens de API.

Próximos pasos

Rostros y conteo de personas

Detecta e identifica personas, y cuenta la ocupación junto con tus análisis de vehículos

Notificaciones por webhook

Recibe notificaciones en tiempo real cuando se detecta un vehículo en la lista de vigilancia

Referencia de la API

Explora los esquemas completos de solicitud y respuesta de cada endpoint de vehículos