pub package Build codecov style: lint


dart_wot is an implementation of the Web of Things Scripting API modelled after the WoT reference implementation node-wot. At the moment, it supports interacting with Things using the Constrained Application Protocol (CoAP), the Hypertext Transfer Protocol (HTTP), and the MQTT protocol.


You can consume Thing Descriptions and interact with a Thing based on its exposed Properties, Actions, and Events. Discovery support is currently limited to the "direct" method (i.e. fetching a TD using a single URL). Exposing Things is not yet supported but will be added in future versions.

Using the Protocol Interfaces in the core package, you can add support for additional protocols in your own application or library. The main requirement for this to work is the existence of a URI scheme for the given protocol.

Getting started

To get started, you first need to install the package by adding it to your pubspec.yaml file. You can use dart pub add dart_wot (for a Dart project) or flutter pub add dart_wot (for a Flutter project) to do so.

You can then use the package in your project by adding import 'package:dart_wot/dart_wot.dart' to your source files.


Below you can find a very basic example for reading a status from a Thing (using the test server). To do so, a Thing Description JSON string is first parsed and turned into a ThingDescription object, which is then passed to a WoT runtime created by a Servient with CoAP support.

import 'package:dart_wot/dart_wot.dart';

Future<void> main(List<String> args) async {
  final CoapClientFactory coapClientFactory = CoapClientFactory(null);
  final servient = Servient()..addClientFactory(coapClientFactory);
  final wot = await servient.start();

  final thingDescriptionJson = '''
    "@context": "",
    "title": "Test Thing",
    "base": "coap://",
    "security": ["nosec_sc"],
    "securityDefinitions": {
      "nosec_sc": {
        "scheme": "nosec"
    "properties": {
      "status": {
        "forms": [
            "href": "/hello"

  final thingDescription = ThingDescription(thingDescriptionJson);
  final consumedThing = await wot.consume(thingDescription);
  final status = await consumedThing.readProperty("status");
  final value = await status.value();

A more complex example can be found in the example directory.

Additional information

The package will be extended gradually over the upcoming months. Support for exposing Things will be added as well as more protocols and security schemes.

Contributions are very welcome. You will soon be able to find guidelines for contributing to the package in a CONTRIBUTING file. Until then, you can already file issues for pointing out bugs or requesting features. You can also open PRs; these have to adhere the defined coding style and linter rules. Contributions will be licensed according to the project licenses (see below).


dart_wot is licensed under the 3-Clause BSD License. See the LICENSE file for more information.

SPDX-License-Identifier: BSD-3-Clause

Note on Third-Party Code

This software includes material copied from Eclipse Thingweb node-wot ( Copyright © 2018 Contributors to the Eclipse Foundation. See the LICENSE-THIRD-PARTY file for more information.


Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in the work by you, shall be licensed as above, without any additional terms or conditions.


This project is currently maintained by the following developers:

Name Email Address GitHub Username
Jan Romann JKRhb


Protocol binding for the Constrained Application Protocol (CoAP). Follows the WoT Binding Templates Specification for CoAP.
Protocol binding for the Hypertext Transfer Protocol (HTTP). Follows the WoT Binding Templates Specification for HTTP.
Protocol binding for the Message Queue Telemetry Transport (MQTT). Follows the latest WoT Binding Templates Specification for MQTT.
Core implementation providing Scripting API implementations, interfaces for protocol bindings, and the Servient class which provides the WoT runtime used for consuming, exposing, and discovering Things.
A W3C Web of Things implementation written in Dart.
Provides Thing Description and Thing Model Definitions that follow the WoT Thing Description Specification.
Defines interfaces that follow the WoT Scripting API Specification.