thingsboard.io

What is ThingsBoard?

ThingsBoard is an open-source IoT platform for connecting devices, collecting and storing their data, processing that data with rules, and visualizing it on dashboards. It is aimed at teams building a connected-product or industrial-monitoring system who want to run the platform themselves or use a hosted version rather than assemble every piece from scratch.

Its core capabilities, as described on the site, cover four areas:

• Device and asset management — provision, monitor and control devices and related entities through server-side APIs, and define relationships between devices, assets and customers.
• Data collection — connect devices using standard IoT protocols including MQTT, CoAP and HTTP.
• Processing and reaction — build rule chains to transform and normalize device data, and raise alarms on telemetry events, attribute changes, device inactivity or user actions.
• Visualization — create dashboards with built-in or custom widgets, and share them with customers.

The site also presents a product ecosystem beyond the main platform: ThingsBoard Edge for edge computing, an IoT Gateway for legacy protocols, and an MQTT Broker for connecting MQTT clients. It lists Community Edition, Cloud, and Professional Edition as the main ways to use it, and notes support for both cloud and on-premises deployment, with a microservices architecture for clustering, scalability and fault tolerance. A SCADA offering is positioned for real-time monitoring and control of industrial processes.

How to choose

• If you want to self-host and customize freely, the open-source Community Edition is the natural starting point.
• If you would rather avoid running infrastructure, the Cloud option removes that burden.
• If you need the fuller feature set, the Professional Edition is the commercial step up.

A practical next step: identify your devices' protocols and your data volume first, then check the relevant documentation pages for Community, Cloud or Professional Edition to confirm the fit before committing. Pricing details are available on the site's pricing page rather than summarized here.

How do I deploy ThingsBoard on-premises or in the cloud?

ThingsBoard supports both cloud and on-premises deployments, and the right choice usually comes down to who manages the infrastructure and how much control you need.

Cloud: The hosted option is ThingsBoard Cloud. You get a managed instance without provisioning servers yourself. This suits small teams, prototypes, or production systems where you would rather not run databases and message brokers. The trade-off is less control over the network, data residency and upgrade timing.

On-premises: You install and operate the platform on your own hardware or private cloud. The page evidence lists Community Edition, Professional Edition and Cloud as separate products, with documentation for each. On-premises makes sense when data must stay inside your network, when you need to integrate with local SCADA or legacy systems, or when you want to control the release cycle. You take on server provisioning, database and broker operations, backups and upgrades.

ThingsBoard also offers Edge for edge computing and an IoT Gateway for legacy protocols, which can matter if devices sit behind unreliable links or use non-standard protocols. The platform connects devices over MQTT, CoAP and HTTP, and the rule engine handles transformation, normalization and alarms. Microservices architecture is described as the route to maximum scalability and fault tolerance, so plan for that if you expect large device counts.

A practical next step: start with the Cloud instance or a single-node Community Edition install, connect one real device over MQTT, and build a dashboard. That tells you quickly whether the deployment model fits before you commit to a clustered on-premises setup.

How does ThingsBoard compare to other IoT platforms for a production project?

ThingsBoard is a credible production choice when your project needs open-source control over device management, telemetry storage, dashboards, and rule-based processing without being locked into a single vendor. Its main differentiator is that the same platform spans MQTT, CoAP, and HTTP device connectivity, cloud or on-premises deployment, and a microservices architecture for scaling. For a production team, that combination matters more than any single feature.

Where it fits best

• Industrial and SCADA-style monitoring: The platform explicitly supports SCADA symbols and real-time process control on dashboards, which suits factory, energy, or building-automation projects.
• On-premises or data-sovereignty requirements: Because it supports on-premises deployments, it is a reasonable candidate when telemetry cannot leave your network.
• Teams that want to self-host and extend: The Community Edition gives you the core platform; the Professional Edition adds functions for larger deployments. You trade convenience for control and infrastructure responsibility.
• Rule-driven workflows: The rule engine handles transformation, normalization, alarms, and reactions to device inactivity or user actions, which reduces custom backend code.

Where alternatives may be better

For a concrete scenario: a 5,000-device building-monitoring project with strict data residency would likely start with a self-hosted ThingsBoard deployment, use the IoT Gateway to bring in legacy Modbus devices, and build alarm rules in the rule engine. A small consumer product with 200 devices and no operations team might instead choose a managed cloud IoT service to avoid running clusters.

Decision criteria

1. Do you need on-premises or hybrid deployment? If yes, ThingsBoard is a strong shortlist candidate.
2. Can your team operate a clustered, microservices-based platform, or do you need a fully managed service?
3. Do you need SCADA-style dashboards and rule-based alarms out of the box, or will you build those separately?
4. How many devices and what protocols? Confirm MQTT, CoAP, or HTTP coverage before committing.

A useful next step is to run a small proof of concept: connect a handful of real devices, build one dashboard, and write one alarm rule. That will reveal whether the operational effort fits your team better than a managed alternative. You can start from the official project at ThingsBoard.

How can I use ThingsBoard to create real-time IoT dashboards?

ThingsBoard builds real-time IoT dashboards by connecting devices first, then binding their telemetry to widgets on a dashboard.

The basic flow

1. Connect devices using standard IoT protocols such as MQTT, CoAP or HTTP.
2. Provision and manage the devices and assets you want to monitor, and define relations between devices, assets, customers and other entities through the server-side APIs.
3. Let telemetry flow in; ThingsBoard stores it in a scalable, fault-tolerant way.
4. Create a dashboard and add built-in or custom widgets that read from that telemetry.
5. Share the dashboard with customers or colleagues who need to watch the same data.

What real-time means here The platform is designed for continuous data collection and visualization, so widgets reflect incoming telemetry rather than a static report. For industrial use, SCADA symbols can be placed on dashboards to monitor and control processes in real time.

Where the rule engine fits Dashboards do not have to show raw device data. Rule chains can transform and normalize incoming data, and raise alarms on telemetry events, attribute updates, device inactivity or user actions. Those alarms and cleaned-up values can then appear as dashboard widgets, which is often what makes a dashboard genuinely useful rather than just noisy.

A concrete scenario A facilities team monitoring pumps could connect controllers over MQTT, define each pump as a device with a relation to its building asset, store pressure and temperature telemetry, add a rule chain that raises an alarm when pressure exceeds a threshold, and place gauges plus an alarm table on a shared dashboard. Operators see the state change as data arrives.

Deployment trade-off ThingsBoard supports both cloud and on-premises deployments, and a microservices architecture for clustering. Cloud is quicker to start with; on-premises suits teams with data-residency or network-isolation requirements, at the cost of running the infrastructure yourself.

Editions The Community Edition is the open-source starting point, the Cloud option keeps the deployment managed, and the Professional Edition adds further functions. Compare them against your needs before committing.

Next step Start by deciding which devices and metrics matter, then check the Community Edition documentation to confirm your protocol and widget needs are covered. If you need managed hosting or advanced features, review ThingsBoard pricing and edition comparison before choosing.

What is the ThingsBoard rule engine and how does it process telemetry data?

ThingsBoard's rule engine is the platform's event-processing layer: it lets you define rule chains that receive incoming events, transform and normalize them, and trigger actions such as raising alarms. The page describes this as processing and reacting to data, with alarms triggered on incoming telemetry, attribute updates, device inactivity, and user actions.

In practice, a rule chain is a sequence of nodes. An event enters at a node (for example, a message from a device over MQTT, CoAP, or HTTP), passes through transformation or filtering nodes, and exits at an action node — saving the data, sending a notification, or raising an alarm. This is how raw device payloads become clean telemetry and how conditions become alerts.

Where it fits in a typical setup

• Devices publish telemetry to ThingsBoard over standard IoT protocols.
• The rule engine receives each message as an event.
• Nodes transform or normalize the payload, filter noise, and route messages.
• Alarms are raised on defined conditions, such as a threshold breach or silence from a device.
• Clean data is stored and later shown in dashboards.

Who benefits

Teams that need device-specific logic — unit conversion, deduplication, alert thresholds, or routing to different outputs — get this without writing a separate processing service. Because rule chains are configured rather than coded from scratch, they are accessible to integrators and operations staff, not only developers.

Trade-offs to weigh

• Rule chains add a configuration layer you must design and maintain; complex chains can become hard to trace.
• Processing logic lives inside the platform, which is convenient but ties that logic to ThingsBoard.
• For very heavy or specialized processing, an external stream processor may still be warranted.

Next step

Sketch one rule chain for a real device: input node, one transform, one alarm condition, one output. If that covers your need, the rule engine is likely sufficient; if you find yourself wanting custom code at every step, plan for an external processing service alongside it. For deployment options and editions, see ThingsBoard.

How much does ThingsBoard cost and what are the differences between Community, Professional, and Cloud editions?

ThingsBoard’s own site points to a pricing page, but the supplied page evidence does not list actual prices. So the practical answer is: costs depend on the edition and deployment model, and you should check the current pricing page for exact figures rather than rely on a static summary.

The clearer distinction is what each edition is for.

All three share the same core idea: connect devices using MQTT, CoAP or HTTP, collect and store telemetry, process it with rule chains, and visualize it in dashboards. The platform also supports cloud and on-premises deployments, and its microservices architecture is aimed at scalability and fault tolerance.

A useful way to decide is to start with the deployment question, not the price question. If you have strict data-residency or network-isolation requirements, compare Community and Professional on-premises. If you want to avoid running infrastructure, look at Cloud. If you are prototyping or have in-house platform engineers, Community is often the natural starting point. For exact costs and edition-by-edition feature limits, use the official pricing page: ThingsBoard Pricing.