Saltar al contenido principal
Esta página fue traducida automáticamente. Si encuentra errores o tiene sugerencias, contáctenos.

​
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, puede:
  • Consultar eventos de detección en toda su 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
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 debe usar. No existe un campo de región, estado ni una puntuación de confianza numérica en los eventos de vehículos; no espere ninguno.

​
Requisitos previos

Antes de comenzar, asegúrese de tener:
  • Una clave de API de Rhombus con acceso de lectura a cámaras (generada en la Consola de Rhombus en Configuración > 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 puede 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

Use getVehicleEvents para recuperar eventos de detección en toda su 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 proporcione.
  • 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 proporcione.
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}")

​
Campos de solicitud

​
startTimeMs
integer
Inicio de la ventana de tiempo (más antiguo) en milisegundos de época.
​
endTimeMs
integer
Fin de la ventana de tiempo (más reciente) en milisegundos de época.
​
deviceUuidFilter
string[]
Devuelve solo eventos de estos UUID de cámara. Se combina con Y (AND) con otros filtros.
​
locationUuidFilter
string[]
Devuelve solo eventos de estos UUID de ubicación. Se combina con Y (AND) con otros filtros.
​
nameQuery
string[]
Devuelve eventos cuyo nombre de vehículo coincida con uno de estos valores. Se combina con O (OR) con otras consultas.
​
licensePlateExactQuery
string[]
Devuelve eventos cuya placa coincida exactamente con uno de estos valores. Se combina con O (OR) con otras consultas.
​
vehicleLabelQuery
string[]
Devuelve eventos etiquetados con una de estas etiquetas de vehículo. Se combina con O (OR) con otras consultas.
​
licensePlateFuzzyQuery
string
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.
​
unnamedQuery
boolean
Si es false, devuelve solo eventos que tienen un nombre; si es true, devuelve solo eventos sin nombre. Omítalo si no lo necesita. Se combina con O (OR) con otras consultas.

​
Campos de respuesta

La respuesta contiene un arreglo events. Cada evento tiene estos campos:
​
uuid
string
Identificador único del evento de vehículo.
​
orgUuid
string
Organización a la que pertenece el evento.
​
deviceUuid
string
UUID de la cámara que reportó la detección.
​
locationUuid
string
Ubicación donde ocurrió la detección.
​
vehicleLicensePlate
string
La cadena de matrícula reconocida.
​
matchingLicensePlates
string[]
Cadenas de placa consideradas coincidencias completas para esta detección.
​
partialLicensePlates
string[]
Cadenas de placa consideradas coincidencias parciales para esta detección.
​
imageS3Key
string
Clave S3 de la imagen completa de la detección. Es una clave de almacenamiento, no una URL.
​
thumbnailS3Key
string
Clave S3 de la miniatura de la detección. Es una clave de almacenamiento, no una URL.
​
eventTimestamp
integer
Cuándo ocurrió la detección, en milisegundos de época.
​
name
string
Nombre del vehículo, si la placa está asociada a un vehículo guardado.
imageS3Key y thumbnailS3Key son claves de almacenamiento S3, no URL de imágenes visualizables directamente. Use los endpoints de medios y grabaciones para recuperar los bytes de la imagen.
Los endpoints getRecentVehicleEvents, getRecentVehicleEventsByLocation y getRecentVehicleEventsForVehicle son heredados (legacy). Prefiera getVehicleEvents para nuevas integraciones: su modelo de filtros/consultas los reemplaza.

​
Flujo 2: Buscar una placa con coincidencia aproximada

Cuando tenga una placa específica que rastrear, searchLicensePlates encuentra cada evento que coincide con ella. Habilite 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')}")

​
Campos de solicitud

​
licensePlate
string
requerido
El número de placa que se busca.
​
startTime
integer
Inicio de la ventana de búsqueda en milisegundos de época. Tenga en cuenta que el campo se llama startTime, no startTimeMs.
​
endTime
integer
Fin de la ventana de búsqueda en milisegundos de época.
​
deviceUuids
string[]
Limita la búsqueda a estos UUID de cámara.
​
fuzzy
boolean
Cuando es true, permite la coincidencia aproximada para caracteres leídos incorrectamente.
El campo forcedFuzziness está obsoleto. Use 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:
​
searchMatchedTerm
string
El término de placa que coincidió con su consulta.
​
searchMatchedType
string
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 desea 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())
​
vehicleLicensePlate
string
requerido
La placa que identifica a este vehículo guardado.
​
createdAtMillis
integer
Marca de tiempo de creación en milisegundos de época.
​
alert
boolean
Si se debe generar una alerta cuando se detecta este vehículo.
​
trust
boolean
Si este vehículo es de confianza (conocido/seguro).
​
name
string
Nombre para mostrar del vehículo.
​
description
string
Descripción de texto libre.
​
thumbnailS3Key
string
Clave S3 de una imagen en miniatura del vehículo.

​
Listar vehículos guardados

Recupere todos los vehículos guardados de su 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')})")
Cada entrada del arreglo vehicles es un vehículo guardado:
​
licensePlate
string
La placa que identifica al vehículo guardado.
​
orgUuid
string
Organización a la que pertenece el vehículo.
​
createdAtMillis
integer
Cuándo se guardó el vehículo, en milisegundos de época.
​
alert
boolean
Si las detecciones generan una alerta.
​
trust
boolean
Si el vehículo es de confianza.
​
name
string
Nombre para mostrar.
​
description
string
Descripción de texto libre.
​
thumbnailS3Key
string
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”. Agregue una etiqueta a una placa con addVehicleLabel y quítela 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())
Para ver todas las etiquetas asignadas en su organización, llame 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)}")

​
Asociar eventos anteriores con un vehículo guardado

Si una placa fue detectada antes de que la guardara como vehículo, use associateEventsToVehicle para adjuntar esos eventos de detección históricos al vehículo guardado. Pase 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())

​
Eliminar un vehículo guardado

Quite un vehículo de su 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())
Cuando una detección se lee mal o se atribuye a la placa equivocada, repórtela 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 su 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. Proporcione la hora de referencia como timestampMs (milisegundos de época) y elija 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')}")
​
deviceUuid
string
requerido
El UUID de cámara sobre el que se genera el informe.
​
timestampMs
integer
Hora de referencia para el informe, como marca de tiempo UNIX en milisegundos.
​
interval
string
requerido
Agrupación del informe. Uno de HOURLY, DAILY, WEEKLY o MONTHLY.
El campo dateLocal está obsoleto. Use 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")
export/vehicleEventsV2 reemplaza al endpoint anterior export/vehicleEvents, que está obsoleto. Use V2 para nuevas integraciones: acepta el modelo de filtros/consultas más completo de getVehicleEvents.

​
Casos de uso

Seguimiento de flotas y proveedores

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

Alertas de lista de vigilancia

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

Análisis de estacionamiento y acceso

Use 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

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

​
Solución de problemas

Confirme que está enviando milisegundos de época, no segundos, y que usa 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.
Las lecturas de LPR pueden variar según la iluminación, el ángulo y la velocidad. Establezca fuzzy: true en searchLicensePlates para tolerar lecturas incorrectas de caracteres, y revise matchingLicensePlates y partialLicensePlates en los eventos devueltos para detectar coincidencias cercanas.
Recuerde 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). Reduzca los resultados moviendo criterios a los filtros o disminuyendo la cantidad de consultas.
imageS3Key y thumbnailS3Key son claves de almacenamiento S3, no URL que pueda abrir directamente. Use los endpoints de medios y grabaciones de Rhombus para obtener el contenido de la imagen de una clave dada.
Reportar una lectura incorrecta requiere el permiso MANAGE_LICENSEPLATES en su clave de API. La exportación CSV requiere REPORT_ADMINISTRATION. Genere o actualice su clave con los permisos necesarios en la Consola de Rhombus en Configuración > API.

​
Próximos pasos

Rostros y conteo de personas

Detecte e identifique personas, y cuente la ocupación junto con sus análisis de vehículos

Notificaciones por webhook

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

Referencia de la API

Explore los esquemas completos de solicitud y respuesta de cada endpoint de vehículos
Última modificación el 8 de julio de 2026