# Connect your equipment. Turn its data into maintenance services.

> You bring the automation and you know the client. Wertek AI brings the platform to watch assets, record observations, manage work orders and offer a recurring service.

For integrators · Wertek AI · https://wertek.ai/integrators/

**In:** Modbus RTU/TCP · MQTT · OPC UA · HTTP → Wertek AI → **Out to:** SCADA / HMI · Historian

**Read-only: Wertek AI does not write to your PLC.**

## Your protocols come in. Your SCADA reads the condition with a read key.

Click any line to see what it is, how it connects and its state.

**Wertek AI:** Asset · Condition · Alert · Work order · Report

### In

#### OT · Plant floor

- **[Wertek AI gateway](https://wertek.ai/energy/gateway/)** — Modbus RTU/TCP, with register maps for 32 devices from 17 brands (Eastron, Schneider, Siemens, Circutor, ABB, Janitza, Carlo Gavazzi…) and capacitor banks. Equipment is already reporting this way.
- **Devices that publish over MQTT** *(With provisioning)* — Banner DXM (wireless vibration, with a 4G modem), Acrel kits and energy meters. Equipment is already reporting this way.
- **Your own flow over HTTP with a key** *(Via Node-RED / Ignition / gateway)* — Node-RED, Ignition, n8n, Python or JavaScript/TypeScript; recipes for Modbus TCP, MQTT and OPC UA, validated with simulated values.
- **OPC UA from Bently Nevada System 1** *(Beta)* — Read connector.
- **[In the field, with the phone](https://wertek.ai/mobile/)** — Observations with photos, video with VibeDiag, acoustic analysis and manual readings (hours, cycles, kWh…).

> S7, EtherNet/IP and generic OPC UA: no driver of our own; you reach them through Node-RED, Ignition or a gateway.

#### IT · Business systems

- **Maintenance and ERP** — They bring in their work orders: SAP PM (Pilot-ready), Odoo (Pilot-ready), SAP B1 (In development).
- **Files** — Assets from CSV or Excel, reviewed before they are applied; WAV, UFF58 and CSV signals.

### Out

#### OT · Plant floor

- **Plant historians** — Wertek AI writes its measurements and asset health to the historian, next to your process data: AVEVA PI (Validated), AVEVA Data Hub (Pilot-ready).
- **SCADA, HMI or Node-RED with a read key** — Ignition, Node-RED or a script reads assets, measurements with their result and recommendation, and energy, to show condition next to the process tags. The read key is created from the Monitoring plan.

> Wertek AI does not write to your PLC: it publishes facts and states, and you decide which tag to touch.

#### IT · Business systems

- **API with a key** — Assets, measurements, signal and FFT, and energy; export in JSON. The read key is created from the Monitoring plan.
- **Downloads** — CSV, XLSX, Parquet, WAV and PDF: measurements, observations, work orders, consumption and grid code compliance.
- **Alerts** — Push and email, and live in the app.
- **Periodic reports by email** — Energy and grid code compliance, condition, and the monthly summary of consumption centers.
- **[Maintenance and ERP](https://wertek.ai/integrations/)** — Connectors, each with its audited state: MaintainX (Pilot-ready), Odoo (Pilot-ready), Fracttal (Pilot-ready), SAP B1 (In development).

## HTTP with a key: the path for any device

1. **Create your free account.** At app.wertek.ai. A key with only the ingest permission works on any plan. [Create account](https://app.wertek.ai/signup)
2. **Create the asset and designate the point.** In the app, register the asset and designate the position you will feed: its code, its variables with their UCUM unit, and its cadence. You can also designate it with the key: POST /iaes/assets/{asset_id}/measurement-points. Designating consumes a point: do it once per position, not on every send.
3. **Create the ingest key.** In Settings → API Keys, with the ingest permission. Keep it as a secret: in an environment variable, never in the code or in a tag.
4. **Send the reading.** One asset.measurement event per reading, alone or in a list of up to 100, to POST https://api.wertek.ai/iaes/ingest. The answer carries one code per event; what is stored appears in the asset's history, under the designated position.

### How to designate a point

1. **In Measurement points (or on the asset), click «Designate position».** Designating uses one point from your organization’s pool: you do it once per position, not on every send.
2. **Fill in the code, the template and the cadence.** The code is the `location` your integration will send (lowercase, no spaces). The template brings the family’s variables with their UCUM unit; you can add custom variables. The contracted cadence, in seconds, is how often you will send a reading.

   ![The «Designate a measurement position» dialog: code, template, variables and cadence](https://wertek.ai/assets/images/integrators/designar-dialogo-en.webp)

3. **The position shows up in the list and starts receiving readings.** Every event you send with that code and the ingest key is stored in the asset’s history, under that position.

### The event (reading.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"
  }
}
```

Validated with the published IAES 2.0.2 SDK, the version the ingest uses.

- `data.location` — the code of the designated position
- `data.measurement_type` — the key of the variable
- `data.unit` — the unit of the contract (compared, never converted)
- `data.value` — a number; booleans travel as 0 or 1
- `timestamp` — the time of the measurement, in UTC — not the time you send it
- `event_id` — new for each reading; it is the idempotency key

### curl

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

### Python

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

event = json.load(open("reading.json"))
event["event_id"] = str(uuid.uuid4())         # new for each reading
event["correlation_id"] = str(uuid.uuid4())   # one per batch
event["timestamp"] = datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")  # when it was measured

r = requests.post(
    "https://api.wertek.ai/iaes/ingest",
    json=[event],
    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
```

Import the flow of the recipe (pump-process-to-wertek.flow.json); the iaes-publish node uses the same key.

### Recipes

- **Node-RED.** Recipe validated in software: its acceptance script runs against the API with simulated values. IAES nodes 2.0.2 imported and run in a real Node-RED 5.0.6 (Docker, 2026-11-12): 5/5 events valid. [Recipe, flow and acceptance script](https://github.com/wertek-ai/wertek-integrations/tree/main/ot/_tools/node-red)
- **n8n.** Recipe verified against the API on 2026-10-05, with no automatic acceptance script. IAES nodes 2.0.2 imported and run in a real n8n 2.8.4 (2026-11-12): 5/5 events valid. [Recipe and workflow](https://github.com/wertek-ai/wertek-integrations/tree/main/ot/_tools/n8n)
- **Any HTTP client.** The base recipe: read the contract of the asset, designate the position, send and read the answer event by event. [Recipe and acceptance script](https://github.com/wertek-ai/wertek-integrations/tree/main/ot/iaes)

### And MQTT?

Today MQTT means lanes for specific equipment — the Banner DXM, Acrel kits and energy meters — each with its own topic and credential, set up with provisioning. There is no universal topic: for any other device, the path is HTTP with a key.

## What protects your data on the way in, and what you control

What the code does today, and nothing beyond it.

- **Ingest keys.** A key starts with wk_ and is shown once, when you create it. Wertek AI stores only its SHA-256 hash and a 12-character prefix to recognize it.
- **Scope, expiry and revocation.** Each key carries its scopes (telemetry.view, telemetry.export, iaes.ingest), can be limited to specific assets, can expire in 1 to 365 days, and can be revoked. Only an owner or admin manages keys.
- **Bound to your organization.** An event is accepted only for assets of the key’s organization: a key cannot write to another organization’s assets.
- **In transit.** The API is served over HTTPS. For MQTT, use port 8883 with TLS.
- **Files behind signed links.** Captures and documents are delivered through links signed with HMAC-SHA256 that expire.
- **Stored data.** Our providers (Supabase for the database and Cloudflare R2 for files) encrypt the data they store.
- **Limits and usage.** Up to 300 requests per minute per machine credential (429 beyond that) and 100 events per batch. The telemetry API records each key’s usage and its last use.

### Recommended for integrators

- MQTT: port 8883 with TLS.
- We don’t recommend sending unencrypted data. If a device doesn’t support TLS, talk to us: it can be evaluated with other protections.
- One key per site, with the minimum scope (iaes.ingest to send data) and an expiry.
- Keep the key in an environment variable or a secrets store, never in the code or the flow.
- Revoke the key when a device or a site leaves.

## Published packages, with their open source code

- **Node-RED** — `npm install node-red-contrib-iaes@2.0.2`. Seven nodes: measurement, health, work-order, validate, sparkplug, publish and route. Published version: 2.0.2 · [Source](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`. Community node for n8n. Published version: 2.0.2 · [Source](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`. Client, models and validation of the event (validation uses ajv). Published version: 2.0.2 · [Source](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"`. Models and validation: the same validator the Wertek AI ingest uses. Published version: 2.0.2 · [Source](https://github.com/wertek-ai/iaes/tree/py-v2.0.2/src/iaes) · [PyPI](https://pypi.org/project/iaes/)

**Preview.** Arduino Opta: iaes-opta-runtime emits IAES 1.4, and the Wertek AI ingest asks for 2.x. It is a preview, not for production. [iaes-opta-runtime](https://github.com/wertek-ai/iaes-opta-runtime)

**IAES: build the flow once.** One open event format, reused with every customer, and what your customer gets in Wertek AI. [See IAES for integrators](https://wertek.ai/integrators/iaes/index.md)

The standard: IAES 2.0, open (CC BY 4.0). [iaes.dev](https://iaes.dev/) · [DOI 10.5281/zenodo.22663498](https://doi.org/10.5281/zenodo.22663498)

## More than a place to store data

- **The asset and its history.** Each reading stays in the history of the asset, under the position you designated.
- **Observations.** Their team records what they find in the field, with photos, from the web or the phone.
- **Work orders.** To act on what was found and keep the record of each intervention. From Technical.
- **The mobile app.** For field work, on Android and iPhone.

## Receiving the data is free; watching it is not.

What you pay for is the watched point, not the asset.

- 1 point: USD 36 per year
- Pack of 5 points: USD 120 per year

Prices from the current Wertek AI catalog, read when this page was published. [See all plans](https://wertek.ai/pricing.html)

## Your client governs the asset; you see what they grant you

- The asset and its history belong to whoever governs it: your client. What you record keeps your authorship.
- You see what your client grants you: by plant, area or asset, with time windows.
- By default, your client pays for the points.
- If you part ways, the asset and its technical history stay with your client; your access ends when it is revoked.

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

## What the ingest accepts

| | |
|---|---|
| Route | POST https://api.wertek.ai/iaes/ingest |
| Header | X-API-Key, with the iaes.ingest permission |
| Event | IAES, spec_version 2.x |
| Batch | up to 100 events per request |
| Limit | 300 requests per minute per key |
| Cadence | a reading that arrives before 90 % of the contracted cadence is dropped (code 504) |
| Contract of the asset | GET /iaes/assets/{asset_id}/measurement-points, with the key |
| Schema and codes | GET /iaes/schema and /iaes/schema/codes, with the key |
| Answer | one code per event: 1xx stored · 2xx stored with a warning · 4xx fix the message · 5xx retry |

## Frequently asked questions

**Do I need a plan?** You do not need a plan to send data; each watched point is paid according to the catalog. The plan turns on alerts that reach someone, work orders and more history.

**Where does it run?** The ingest is a Wertek AI cloud service. The Wertek AI gateway does run on your network: it reads the equipment and pushes the readings.

**Does the ingest write to my PLC?** No. The ingest only receives data.

**What if I send faster than the cadence?** A reading that arrives before 90 % of the contracted cadence is dropped with code 504. Match your sends to the cadence of the point.

