> ## Documentation Index
> Fetch the complete documentation index at: https://docs.kodelabs.com/llms.txt
> Use this file to discover all available pages before exploring further.

# What are Integrations?

> Connect 200+ external systems to KODE OS to discover, collect, and act on building data

> Connect external systems to KODE OS to discover, collect, and act on building data

KODE OS integrations connect your building systems to a single platform. You configure a connector, discover devices and points, and start collecting data from the `Data Sources` page in your building. With 200+ supported systems across access control, metering, occupancy, lighting, HVAC, and more, integrations give you a consistent view of every system in your portfolio.

## What you can do

KODE OS integrations support five core capabilities. Each integration may support one or more of these depending on the external system.

<CardGroup cols={3}>
  <Card title="Discover" icon="search" href="/products/integrations/capabilities/discovery">
    Automatically find devices, points, schedules, and assets from connected systems
  </Card>

  <Card title="Collect data" icon="database" href="/products/integrations/capabilities/data-collection">
    Pull or receive sensor readings, work orders, alarms, and events on a schedule or in real time
  </Card>

  <Card title="Actions" icon="zap" href="/products/integrations/capabilities/actions">
    Send commands to devices, create work orders, or update records in external systems
  </Card>

  <Card title="Schedules" icon="calendar" href="/products/integrations/capabilities/schedules">
    Manage time-based configurations like HVAC programs and lighting routines
  </Card>

  <Card title="MQTT" icon="radio" href="/products/integrations/capabilities/mqtt">
    Connect IoT devices using lightweight publish/subscribe messaging
  </Card>
</CardGroup>

### Discover

Discovery is a user-initiated process that finds devices, points, schedules, and other assets from a connector. You do not configure each item by hand. KODE OS queries the external system and lists available sensors, cameras, door readers, meters, and more.

* **Devices and points**: Available devices and their data points
* **Schedules**: Schedules or calendars already configured in the third-party system (when supported)
* **Assets**: Non-sensor metadata objects such as furniture, network equipment, or safety equipment

See the [Discovery guide](/products/integrations/capabilities/discovery).

### Collect data

Collect data means gathering information about discovered entities. Depending on the external system, this can happen in two ways:

* **Scheduled pull**: KODE OS connects to the connector at regular intervals. Protocols include REST, SOAP, FTP/SFTP, SDKs, and OpenSSL/TCP.
* **Real-time push**: The third-party system sends data as events occur. Protocols include MQTT, WebSockets, and webhooks.

Data collection supports three modes:

* **Snapshot**: The current state at a specific moment
* **Delta**: Only changes since the last collection
* **Historical**: A complete log of past values over time

See the [Data collection guide](/products/integrations/capabilities/data-collection).

### Actions

Actions are commands sent to devices or requests made to external systems to change a value or trigger an event. KODE OS supports:

* **Point actions**: Set a new value on a point (for example, thermostat temperature or light on for two hours)
* **Entity actions**: Create or update records in external systems (for example, a work order)
* **Schedule actions**: Create, update, or delete schedules in the external system

See the [Actions guide](/products/integrations/capabilities/actions).

### Schedules

Schedules manage time-based configurations in external systems. KODE OS supports two schedule types:

* **Calendar schedules**: Exceptions or one-time events such as holidays, maintenance windows, and temporary overrides
* **Weekly schedules**: Recurring routines for each day of the week such as business hours and off-hours settings

See the [Schedules guide](/products/integrations/capabilities/schedules).

## How it works

The integration lifecycle follows the same flow for every external system.

```mermaid theme={"theme":{"light":"github-light","dark":"github-dark"}}
flowchart LR
    A["Browse API Catalog"] --> B["Add connector"]
    B --> C["Configure connector"]
    C --> D["Discover devices and points"]
    D --> E["Map with ontology"]
    E --> F["Collect data"]
    F --> G["Take actions"]
```

To walk through this flow in the product, follow the [Quickstart](/products/integrations/get-started/quickstart).

## Core concepts

These terms appear throughout KODE OS integrations documentation.

### API

An API (Application Programming Interface) is a defined way for software systems to exchange data and commands. KODE OS uses APIs to talk to external building systems.

### Connector

A connector is the configured connection from KODE OS to one external system. In the UI, connectors live on the `Data Sources` page. Older labels may still say datasource. Prefer connector in documentation and conversation.

Different vendors use different protocols such as MQTT, Modbus, or HTTPS. Each connector type knows how to speak to that vendor or system family.

### Device

A device is the physical or logical piece of equipment you monitor or control, such as a thermostat, light fixture, or motion sensor. Devices connect to KODE OS through a connector.

### Point

A point is an individual data value, measurement, or control option on a device. Examples include a temperature reading, a turn-on command, or a door-open status.

### Sensor data and non-sensor data

**Sensor data** is measurable, often time-stamped values from device points. Examples include room temperature, occupancy status, air quality, and water flow.

**Non-sensor data** is building information that is not generated by a physical sensor. Examples include reservations, visitor entries, alarms, and completed inspection checklists.

### Schedules

A schedule defines time-based rules for automating behavior. It tells the system what to run, when to run it, and how often. Examples include lights off at 8 PM and HVAC start at 6 AM on weekdays.

### Ontology

Ontology is the common vocabulary KODE OS uses to name and organize devices, points, and other entities from different vendors. Vendors often use different labels for the same concept:

| Third-party system | What they call it   |
| ------------------ | ------------------- |
| System A           | `temp_sensor`       |
| System B           | `temperature probe` |
| System C           | `TS01`              |

Ontology maps those names to a standard type in Cloud BMS. For example, all three map to a Temperature Sensor device type with a Temperature point type.

The ontology workflow is:

1. **Discover** — KODE OS finds devices and points and saves each native identifier
2. **Map** — Each object maps to a standardized type, either during discovery or manually in Cloud BMS
3. **Operate** — You collect data, trigger actions, and monitor devices with consistent names

You apply ontology in `Cloud BMS` after you discover devices from a connector.

### Dynamic APIs

Some systems, such as Niagara or BACnet servers, do not expose a fixed list of device and point types. Available objects appear at runtime when you discover them.

For dynamic integrations:

1. **Connect** — KODE OS connects to the external system
2. **Discover** — KODE OS reads available objects
3. **Map** — You often map each object to a standard type manually in Cloud BMS
4. **Operate** — After mapping, you collect data and run actions as with any other integration

<Note>
  Check the specific integration page to see whether your system uses a dynamic or fixed API structure.
</Note>

## Communication protocols

KODE OS uses different protocols depending on the external system.

| Protocol            | Role                                                                                       |
| ------------------- | ------------------------------------------------------------------------------------------ |
| **REST**            | Common web API style over HTTPS using methods such as GET, POST, PUT, and DELETE           |
| **SOAP**            | XML-based messaging, often used by legacy systems and defined by a WSDL                    |
| **Webhook**         | The external system pushes an HTTP request to KODE OS when an event occurs                 |
| **MQTT**            | Lightweight publish/subscribe messaging for constrained devices and low-bandwidth networks |
| **WebSocket**       | Full-duplex real-time messaging over a single TCP connection                               |
| **SDK**             | Vendor libraries that call the external system directly                                    |
| **OpenSSL / TCP**   | Raw socket communication for custom or low-level integrations                              |
| **SFTP / FTP**      | Scheduled file transfer for systems that exchange CSV or XML files                         |
| **Modbus / BACnet** | Building automation protocols for HVAC units, meters, and controllers                      |

See [MQTT integrations](/products/integrations/capabilities/mqtt) for broker, topic, and QoS details.

## Environments

Connectors can run in the cloud or on premises.

* **Cloud**: Hosted on platforms such as AWS, GCP, or Azure and reached over the internet
* **Local (on-premises)**: Installed in the building or client network; may require VPN access to KODE OS

Common infrastructure pieces include servers, databases, network paths, IP addresses or URLs, credentials or certificates, firewalls, and API gateways.

## Next steps

<CardGroup cols={2}>
  <Card title="Quickstart" icon="bolt" href="/products/integrations/get-started/quickstart" arrow={true} cta="Start">
    Connect your first external system and verify data flow
  </Card>

  <Card title="Managing connectors" icon="plug" href="/products/integrations/get-started/managing-connectors" arrow={true} cta="Learn">
    Configure, test, and monitor connectors day to day
  </Card>

  <Card title="Integrations catalog" icon="grid-2x2" href="/products/integrations/catalog" arrow={true} cta="Browse">
    Find your integration among 200+ supported systems
  </Card>

  <Card title="Discovery" icon="search" href="/products/integrations/capabilities/discovery" arrow={true} cta="Learn">
    Understand how device, point, schedule, and asset discovery works
  </Card>
</CardGroup>