> ## Índice de la documentación
> Consulta el índice completo de la documentación en: https://developer.rhombus.com/llms.txt
> Úsalo para descubrir todas las páginas disponibles antes de seguir explorando.

# Reconocimiento de matrículas y vehículos

> Consulta eventos de detección de matrículas, busca placas con coincidencia aproximada, crea una lista de vigilancia de vehículos guardados, genera informes por dispositivo y exporta datos de vehículos como CSV con la API de Rhombus.

> **Note**: Esta página se tradujo automáticamente. Si encuentras errores o tienes sugerencias, [escríbenos](mailto:support@rhombus.com).

## 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

> **Note**: 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

> **Note**: 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](https://console.rhombussystems.com/settings/integrations/api-tokens/) 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.

```python Python
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}")
```

```javascript JavaScript
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}`);
}
```

```bash cURL
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

- **`startTimeMs` (body, integer)**: Inicio de la ventana de tiempo (más antiguo) en milisegundos de época.
- **`endTimeMs` (body, integer)**: Fin de la ventana de tiempo (más reciente) en milisegundos de época.
- **`deviceUuidFilter` (body, string\[])**: Devuelve solo eventos de estos UUID de cámara. Se combina con Y (AND) con otros filtros.
- **`locationUuidFilter` (body, string\[])**: Devuelve solo eventos de estos UUID de ubicación. Se combina con Y (AND) con otros filtros.
- **`nameQuery` (body, string\[])**: Devuelve eventos cuyo nombre de vehículo coincida con uno de estos valores. Se combina con O (OR) con otras consultas.
- **`licensePlateExactQuery` (body, string\[])**: Devuelve eventos cuya placa coincida exactamente con uno de estos valores. Se combina con O (OR) con otras consultas.
- **`vehicleLabelQuery` (body, string\[])**: Devuelve eventos etiquetados con una de estas etiquetas de vehículo. Se combina con O (OR) con otras consultas.
- **`licensePlateFuzzyQuery` (body, 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` (body, boolean)**: 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:

- **`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.

> **Warning**: `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.

> **Note**: 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.

```python Python
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')}")
```

```javascript JavaScript
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})`);
}
```

```bash cURL
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

- **`licensePlate` (body, string, required)**: El número de placa que se busca.
- **`startTime` (body, integer)**: Inicio de la ventana de búsqueda en milisegundos de época. Ten en cuenta que el campo se llama `startTime`, no `startTimeMs`.
- **`endTime` (body, integer)**: Fin de la ventana de búsqueda en milisegundos de época.
- **`deviceUuids` (body, string\[])**: Limita la búsqueda a estos UUID de cámara.
- **`fuzzy` (body, boolean)**: Cuando es `true`, permite la coincidencia aproximada para caracteres leídos incorrectamente.

> **Warning**: 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](https://developer.rhombus.com/es/implementations/lpr-vehicle#campos-de-respuesta) del Flujo 1, más dos campos específicos de la búsqueda:

- **`searchMatchedTerm` (string)**: El término de placa que coincidió con tu 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 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

```python Python
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())
```

```javascript JavaScript
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());
```

```bash cURL
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
  }'
```

- **`vehicleLicensePlate` (body, string, required)**: La placa que identifica a este vehículo guardado.
- **`createdAtMillis` (body, integer)**: Marca de tiempo de creación en milisegundos de época.
- **`alert` (body, boolean)**: Si se debe generar una alerta cuando se detecta este vehículo.
- **`trust` (body, boolean)**: Si este vehículo es de confianza (conocido/seguro).
- **`name` (body, string)**: Nombre para mostrar del vehículo.
- **`description` (body, string)**: Descripción de texto libre.
- **`thumbnailS3Key` (body, string)**: 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.

```python Python
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')})")
```

```javascript JavaScript
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})`);
}
```

```bash cURL
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:

- **`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". Agrega una etiqueta a una placa con `addVehicleLabel` y quítala con `removeVehicleLabel`.

```python Python
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())
```

```javascript JavaScript
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());
```

```bash cURL
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.

```python Python
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)}")
```

```javascript JavaScript
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(', ')}`);
}
```

```bash cURL
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.

```python Python
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())
```

```javascript JavaScript
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());
```

```bash cURL
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.

```python Python
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())
```

```javascript JavaScript
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());
```

```bash cURL
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"}'
```

> **Tip**: 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`.

```python Python
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')}")
```

```javascript JavaScript
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}`);
}
```

```bash cURL
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"
  }'
```

- **`deviceUuid` (body, string, required)**: El UUID de cámara sobre el que se genera el informe.
- **`timestampMs` (body, integer)**: Hora de referencia para el informe, como marca de tiempo UNIX en milisegundos.
- **`interval` (body, string, required)**: Agrupación del informe. Uno de `HOURLY`, `DAILY`, `WEEKLY` o `MONTHLY`.

> **Warning**: 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](https://developer.rhombus.com/es/implementations/lpr-vehicle#campos-de-respuesta) 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`.

```python Python
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")
```

```javascript JavaScript
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);
```

```bash cURL
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
```

> **Note**: `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](https://console.rhombussystems.com/settings/integrations/api-tokens/) en **Configuración → Integraciones y recursos para desarrolladores → Tokens de API**.

## Próximos pasos

- **[Rostros y conteo de personas](https://developer.rhombus.com/es/implementations/faces-people-counting)**: Detecta e identifica personas, y cuenta la ocupación junto con tus análisis de vehículos
- **[Notificaciones por webhook](https://developer.rhombus.com/es/webhooks)**: Recibe notificaciones en tiempo real cuando se detecta un vehículo en la lista de vigilancia
- **[Referencia de la API](https://developer.rhombus.com/api-reference/vehicle-webservice/get-vehicle-events)**: Explora los esquemas completos de solicitud y respuesta de cada endpoint de vehículos