diff --git a/docs/pe/org.apache.streampipes.connect.iiot.adapters.oi4.md b/docs/pe/org.apache.streampipes.connect.iiot.adapters.oi4.md
new file mode 100644
index 0000000..2852ac3
--- /dev/null
+++ b/docs/pe/org.apache.streampipes.connect.iiot.adapters.oi4.md
@@ -0,0 +1,87 @@
+---
+id: org.apache.streampipes.connect.iiot.adapters.oi4
+title: OI4
+sidebar_label: OI4
+---
+
+<!--
+  ~ Licensed to the Apache Software Foundation (ASF) under one or more
+  ~ contributor license agreements.  See the NOTICE file distributed with
+  ~ this work for additional information regarding copyright ownership.
+  ~ The ASF licenses this file to You under the Apache License, Version 2.0
+  ~ (the "License"); you may not use this file except in compliance with
+  ~ the License.  You may obtain a copy of the License at
+  ~
+  ~    http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  ~ See the License for the specific language governing permissions and
+  ~ limitations under the License.
+  ~
+  -->
+
+# Open Industry 4.0 (OI4)
+
+<p align="center"> 
+    <img src="/img/pipeline-elements/org.apache.streampipes.connect.iiot.adapters.oi4/icon.png" width="150px;" class="pe-image-documentation"/>
+</p>
+
+---
+
+
+
+The OI4 adapter facilitates the integration of any OT-device compliant with the OI4 standard into Apache StreamPipes.
+For detailed information about this standard, please refer to their [development guide](https://openindustry4.com/fileadmin/Dateien/Downloads/OEC_Development_Guideline_V1.1.1.pdf).
+
+### Requirements
+
+Your OI4-compatible device should emit data via an MQTT broker.
+
+### Restrictions
+
+This adapter exclusively allows data consumption from a specific MQTT topic.
+If you have different requirements, please notify us through the mailing list or GitHub discussions.
+
+---
+
+## Configuration
+
+Below is a list of the configuration parameters you need to provide.
+
+### Broker URL
+
+Enter the URL of the broker, including the protocol and port number (e.g., `tcp://10.20.10.3:1883`).
+
+### Access Mode
+
+Choose between unauthenticated access or input your credentials for authenticated access.
+
+### Sensor Description
+
+You should provide information about the sensor you want to connect to. This can be achieved in two ways:
+
+a) **By Type**: Specify the type of sensor you want to connect to, e.g., `'VVB001'`. <br>
+b) **By IODD**: Simply upload the IODD description of the respective sensor. Please note: This feature is not yet available! If you're interested in this feature, please notify us through the mailing list or GitHub discussions and share your use case with us.
+
+### Selected Sensors
+
+Configure which sensors of the master device you want to connect to. You can either select `All`, which will provide data from all sensors available on the respective MQTT topic, or choose `Custom Selection` and provide a list of sensor IDs in a comma-separated string (e.g., `000008740649,000008740672`).
+
+## Output
+
+The output consists of all values from the selected sensor type. Below is an example for the `VVB001 sensor`:
+
+```json
+{
+    "a-Rms": 1.8,
+    "OUT2": true,
+    "SensorID": "000008740649",
+    "Temperature": 22,
+    "Crest": 3.7,
+    "v-Rms": 0.0023,
+    "OUT1": true,
+    "Device status": 0,
+    "timestamp": 1685525380729
+}
diff --git a/website-v2/sidebars.json b/website-v2/sidebars.json
index 3d977fa..47b03e1 100644
--- a/website-v2/sidebars.json
+++ b/website-v2/sidebars.json
@@ -41,6 +41,7 @@
           "pe/org.apache.streampipes.connect.iiot.protocol.stream.nats",
           "pe/org.apache.streampipes.connect.iiot.adapters.netio.mqtt",
           "pe/org.apache.streampipes.connect.iiot.adapters.netio.rest",
+          "pe/org.apache.streampipes.connect.iiot.adapters.oi4",
           "pe/org.apache.streampipes.connect.iiot.adapters.opcua",
           "pe/org.apache.streampipes.connect.iiot.adapters.plc4x.modbus",
           "pe/org.apache.streampipes.connect.iiot.adapters.plc4x.s7",
diff --git a/website-v2/static/img/pipeline-elements/org.apache.streampipes.connect.iiot.adapters.oi4/icon.png b/website-v2/static/img/pipeline-elements/org.apache.streampipes.connect.iiot.adapters.oi4/icon.png
new file mode 100644
index 0000000..970781d
--- /dev/null
+++ b/website-v2/static/img/pipeline-elements/org.apache.streampipes.connect.iiot.adapters.oi4/icon.png
Binary files differ
