# Conecta tus equipos. Convierte sus datos en servicios de mantenimiento.

> Tú aportas la automatización y conoces al cliente. Wertek AI aporta la plataforma para vigilar activos, registrar observaciones, gestionar órdenes de trabajo y ofrecer un servicio recurrente.

Para integradores · Wertek AI · https://wertek.ai/es/integrators/

**Entra:** Modbus RTU/TCP · MQTT · OPC UA · HTTP → Wertek AI → **Sale a:** SCADA / HMI · Historiador

**Sólo lectura: Wertek AI no escribe en tu PLC.**

## Tus protocolos entran. Tu SCADA lee la condición con una llave de lectura.

Cada línea se abre con un clic: qué es, cómo se conecta y su estado.

**Wertek AI:** Activo · Condición · Aviso · Orden de trabajo · Reporte

### Entra

#### OT · Piso de planta

- **[Gateway de Wertek AI](https://wertek.ai/energy/gateway/)** — Modbus RTU/TCP, con mapas de registros para 32 equipos de 17 marcas (Eastron, Schneider, Siemens, Circutor, ABB, Janitza, Carlo Gavazzi…) y bancos de capacitores. Ya hay equipos reportando por aquí.
- **Equipos que publican por MQTT** *(Con aprovisionamiento)* — Banner DXM (vibración inalámbrica, con módem 4G), kits Acrel y medidores de energía. Ya hay equipos reportando por aquí.
- **Tu propio flujo por HTTP con llave** *(Vía Node-RED / Ignition / gateway)* — Node-RED, Ignition, n8n, Python o JavaScript/TypeScript; recetas para Modbus TCP, MQTT y OPC UA, validadas con valores simulados.
- **OPC UA de Bently Nevada System 1** *(Beta)* — Conector de lectura.
- **[Campo, con el teléfono](https://wertek.ai/es/mobile/)** — Observaciones con fotos, video con VibeDiag, análisis acústico y lecturas manuales (horas, ciclos, kWh…).

> S7, EtherNet/IP y OPC UA genérico: sin driver propio; se llega por Node-RED, Ignition o un gateway.

#### IT · Sistemas

- **Mantenimiento y ERP** — Traen sus órdenes de trabajo: SAP PM (Pilot-ready), Odoo (Pilot-ready), SAP B1 (In development).
- **Archivos** — Activos desde CSV o Excel, revisados antes de aplicarse; señales WAV, UFF58 y CSV.

### Sale

#### OT · Piso de planta

- **Historiadores de planta** — Wertek AI escribe sus mediciones y la salud del activo en el historiador, junto a tus datos de proceso: AVEVA PI (Validated), AVEVA Data Hub (Pilot-ready).
- **SCADA, HMI o Node-RED con una llave de lectura** — Ignition, Node-RED o un script leen activos, mediciones con su resultado y recomendación, y energía, para mostrar la condición junto a los tags de proceso. La llave de lectura se crea desde el plan Monitoring.

> Wertek AI no escribe en tu PLC: publica hechos y estados, y tú decides qué tag tocar.

#### IT · Sistemas

- **API con llave** — Activos, mediciones, señal y FFT, y energía; exporte en JSON. La llave de lectura se crea desde el plan Monitoring.
- **Descargas** — CSV, XLSX, Parquet, WAV y PDF: mediciones, observaciones, órdenes, consumo y Código de Red.
- **Avisos** — Push y correo, y en vivo en la app.
- **Informes periódicos por correo** — Energía y Código de Red, condición y resumen mensual de centros de consumo.
- **[Mantenimiento y ERP](https://wertek.ai/es/integrations/)** — Conectores, cada uno con su estado auditado: MaintainX (Pilot-ready), Odoo (Pilot-ready), Fracttal (Pilot-ready), SAP B1 (In development).

## HTTP con una llave: el camino para cualquier equipo

1. **Crea tu cuenta gratis.** En app.wertek.ai. Una llave con sólo el permiso de ingesta funciona en cualquier plan. [Crear cuenta](https://app.wertek.ai/signup)
2. **Crea el activo y designa el punto.** En la app das de alta el activo y designas la posición que vas a alimentar: su código, sus variables con su unidad UCUM y su cadencia. También se puede designar con la llave: POST /iaes/assets/{asset_id}/measurement-points. Designar consume un punto: se hace una vez por posición, no en cada envío.
3. **Crea la llave de ingesta.** En Configuración → Claves API, con el permiso de ingesta. Guárdala como secreto: en una variable de entorno, nunca en el código ni en un tag.
4. **Manda la lectura.** Un evento asset.measurement por lectura, solo o en una lista de hasta 100, a POST https://api.wertek.ai/iaes/ingest. La respuesta trae un código por evento; lo guardado aparece en la historia del activo, bajo la posición designada.

### Cómo designar un punto

1. **En Puntos de medición (o en el activo), pulsa «Designar posición».** Designar consume un punto del saldo de tu organización: se hace una vez por posición, no en cada envío.
2. **Llena el código, la plantilla y la cadencia.** El código es el `location` que mandará tu integración (minúsculas, sin espacios). La plantilla trae las variables de la familia con su unidad UCUM; puedes agregar variables a la medida. La cadencia contratada, en segundos, es cada cuánto mandarás una lectura.

   ![El diálogo «Designar una posición de medición»: código, plantilla, variables y cadencia](https://wertek.ai/assets/images/integrators/designar-dialogo-es.webp)

3. **La posición aparece en la lista y empieza a recibir lecturas.** Cada evento que mandes con ese código y la llave de ingesta se guarda en el historial del activo, bajo esa posición.

### El evento (lectura.json)

```json
{
  "spec_version": "2.0",
  "event_id": "6f1c2b7e-3d4a-4e8b-9a10-5c2d7e9f1a34",
  "correlation_id": "0b8e4c21-7f3a-4d6e-8c95-1a2b3c4d5e6f",
  "event_type": "asset.measurement",
  "timestamp": "2026-11-11T14:32:00Z",
  "source": "plant_x.plc_12",
  "dataschema": "https://iaes.dev/schema/v2/asset.measurement",
  "asset": {
    "asset_id": "PUMP-07"
  },
  "data": {
    "measurement_type": "temperature",
    "value": 23.5,
    "unit": "Cel",
    "location": "zona_1"
  }
}
```

Validado con el SDK de IAES 2.0.2 publicado, la versión que usa la ingesta.

- `data.location` — el código de la posición designada
- `data.measurement_type` — la clave de la variable
- `data.unit` — la unidad del contrato (se compara, nunca se convierte)
- `data.value` — un número; los booleanos viajan como 0 o 1
- `timestamp` — la hora de la medición, en UTC — no la hora del envío
- `event_id` — uno nuevo por lectura; es la llave de idempotencia

### curl

```bash
curl -X POST https://api.wertek.ai/iaes/ingest \
  -H "X-API-Key: $WERTEK_API_KEY" \
  -H "Content-Type: application/json" \
  -d @lectura.json
```

### Python

```python
# pip install requests          (el validador: pip install "iaes[validate]==2.0.2")
import json, os, uuid
from datetime import datetime, timezone
import requests

evento = json.load(open("lectura.json"))
evento["event_id"] = str(uuid.uuid4())         # uno nuevo por lectura
evento["correlation_id"] = str(uuid.uuid4())   # uno por lote
evento["timestamp"] = datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")  # cuándo se midió

r = requests.post(
    "https://api.wertek.ai/iaes/ingest",
    json=[evento],
    headers={"X-API-Key": os.environ["WERTEK_API_KEY"]},
    timeout=30,
)
print(r.status_code, r.json())
```

### Node-RED

```bash
cd ~/.node-red
npm install node-red-contrib-iaes@2.0.2
```

Importa el flujo de la receta (pump-process-to-wertek.flow.json); el nodo iaes-publish usa la misma llave.

### Recetas

- **Node-RED.** Receta validada en software: su script de aceptación corre contra la API con valores simulados. Nodos IAES 2.0.2 importados y ejecutados en un Node-RED 5.0.6 real (Docker, 2026-11-12): 5/5 eventos válidos. [Receta, flujo y script de aceptación](https://github.com/wertek-ai/wertek-integrations/tree/main/ot/_tools/node-red)
- **n8n.** Receta verificada contra la API el 2026-10-05, sin script de aceptación automático. Nodos IAES 2.0.2 importados y ejecutados en un n8n 2.8.4 real (2026-11-12): 5/5 eventos válidos. [Receta y flujo de trabajo](https://github.com/wertek-ai/wertek-integrations/tree/main/ot/_tools/n8n)
- **Cualquier cliente HTTP.** La receta base: lee el contrato del activo, designa la posición, manda y lee la respuesta evento por evento. [Receta y script de aceptación](https://github.com/wertek-ai/wertek-integrations/tree/main/ot/iaes)

### ¿Y MQTT?

Hoy MQTT son carriles de equipos concretos —el DXM de Banner, kits Acrel y medidores de energía—, cada uno con su tópico y su credencial, con aprovisionamiento. No hay un tópico universal: para cualquier otro equipo, el camino es HTTP con llave.

## Qué protege tu dato al entrar, y qué controlas tú

Lo que hace el código hoy, y nada más.

- **Llaves de ingesta.** Una llave empieza con wk_ y se muestra una sola vez, al crearla. Wertek AI guarda sólo su hash SHA-256 y un prefijo de 12 caracteres para reconocerla.
- **Alcance, vencimiento y revocación.** Cada llave lleva sus permisos (telemetry.view, telemetry.export, iaes.ingest), puede limitarse a activos concretos, vencer de 1 a 365 días y revocarse. Sólo un propietario o administrador administra las llaves.
- **Atada a tu organización.** Un evento sólo se acepta para activos de la organización de la llave: una llave no escribe en activos de otra organización.
- **En tránsito.** La API se sirve por HTTPS. Para MQTT, usa el puerto 8883 con TLS.
- **Archivos con enlaces firmados.** Capturas y documentos se entregan con enlaces firmados con HMAC-SHA256 que vencen.
- **Datos almacenados.** Nuestros proveedores (Supabase para la base de datos y Cloudflare R2 para archivos) cifran los datos almacenados.
- **Límites y uso.** Hasta 300 peticiones por minuto por credencial de máquina (429 al pasarse) y 100 eventos por lote. La API de telemetría registra el uso de cada llave y su último uso.

### Recomendado para integradores

- MQTT: puerto 8883 con TLS.
- No recomendamos enviar datos sin cifrar. Si algún equipo no soporta TLS, consúltanos: se puede evaluar con otras protecciones.
- Una llave por sitio, con el permiso mínimo (iaes.ingest para enviar) y con vencimiento.
- La llave en una variable de entorno o un almacén de secretos, nunca en el código ni en el flujo.
- Revoca la llave cuando un equipo o un sitio se va.

## Paquetes publicados, con su código abierto

- **Node-RED** — `npm install node-red-contrib-iaes@2.0.2`. Siete nodos: measurement, health, work-order, validate, sparkplug, publish y route. Versión publicada: 2.0.2 · [Código](https://github.com/wertek-ai/iaes/tree/nodered-v2.0.2/node-red) · [npm](https://www.npmjs.com/package/node-red-contrib-iaes)
- **n8n** — `npm install n8n-nodes-iaes@2.0.2`. Nodo comunitario para n8n. Versión publicada: 2.0.2 · [Código](https://github.com/wertek-ai/iaes/tree/n8n-v2.0.2/n8n-nodes) · [npm](https://www.npmjs.com/package/n8n-nodes-iaes)
- **JavaScript / TypeScript** — `npm install @iaes/sdk@2.0.2`. Cliente, modelos y validación del evento (la validación usa ajv). Versión publicada: 2.0.2 · [Código](https://github.com/wertek-ai/iaes/tree/sdk-v2.0.2/npm) · [npm](https://www.npmjs.com/package/@iaes/sdk)
- **Python** — `pip install "iaes[validate]==2.0.2"`. Modelos y validación: el mismo validador que usa la ingesta de Wertek AI. Versión publicada: 2.0.2 · [Código](https://github.com/wertek-ai/iaes/tree/py-v2.0.2/src/iaes) · [PyPI](https://pypi.org/project/iaes/)

**Vista previa.** Arduino Opta: iaes-opta-runtime emite IAES 1.4, y la ingesta de Wertek AI pide 2.x. Es una vista previa, no para producción. [iaes-opta-runtime](https://github.com/wertek-ai/iaes-opta-runtime)

**IAES: arma el flujo una vez.** Un formato abierto de eventos, reusado con cada cliente, y lo que tu cliente recibe en Wertek AI. [Ver IAES para integradores](https://wertek.ai/es/integrators/iaes/index.md)

El estándar: IAES 2.0, abierto (CC BY 4.0). [iaes.dev](https://iaes.dev/) · [DOI 10.5281/zenodo.22663498](https://doi.org/10.5281/zenodo.22663498)

## Más que un lugar donde guardar datos

- **El activo y su historia.** Cada lectura queda en la historia del activo, bajo la posición que designaste.
- **Observaciones.** Su equipo registra en campo lo que encuentra, con fotografías, desde la web o el teléfono.
- **Órdenes de trabajo.** Para atender lo que se encontró y guardar el registro de cada intervención. Desde Technical.
- **La app móvil.** Para el trabajo de campo, en Android y iPhone.

## Recibir el dato es gratis; vigilarlo, no.

Lo que se paga es el punto vigilado, no el activo.

- 1 punto: USD 36 al año
- Paquete de 5 puntos: USD 120 al año

Precios del catálogo vigente de Wertek AI, leídos al publicar esta página. [Ver todos los planes](https://wertek.ai/pricing.html)

## Tu cliente gobierna su activo; tú ves lo que te concede

- El activo y su historia son de quien lo gobierna: tu cliente. Lo que tú registras conserva tu autoría.
- Ves lo que tu cliente te concede: por planta, área o activo, con ventanas de tiempo.
- Por omisión, los puntos los paga tu cliente.
- Si se separan, el activo y su historia técnica se quedan con tu cliente; tu acceso termina cuando se revoca.

[Conoce el Growth Program](https://wertek.ai/growth-program.html)

## Lo que la ingesta acepta

| | |
|---|---|
| Ruta | POST https://api.wertek.ai/iaes/ingest |
| Encabezado | X-API-Key, con el permiso iaes.ingest |
| Evento | IAES, spec_version 2.x |
| Lote | hasta 100 eventos por petición |
| Límite | 300 peticiones por minuto por llave |
| Cadencia | una lectura que llega antes del 90 % de la cadencia contratada se descarta (código 504) |
| Contrato del activo | GET /iaes/assets/{asset_id}/measurement-points, con la llave |
| Esquema y códigos | GET /iaes/schema y /iaes/schema/codes, con la llave |
| Respuesta | un código por evento: 1xx guardado · 2xx guardado con aviso · 4xx corrige el mensaje · 5xx reintenta |

## Preguntas frecuentes

**¿Necesito plan?** Para mandar datos no necesitas plan; cada punto vigilado se paga según el catálogo. El plan enciende alertas que llegan a alguien, órdenes de trabajo y más historia.

**¿Dónde corre?** La ingesta es un servicio en la nube de Wertek AI. El gateway de Wertek AI sí corre en tu red: lee los equipos y empuja las lecturas.

**¿La ingesta escribe en mi PLC?** No. La ingesta sólo recibe datos.

**¿Qué pasa si mando más rápido que la cadencia?** Una lectura que llega antes del 90 % de la cadencia contratada se descarta con el código 504. Ajusta tus envíos a la cadencia del punto.

