Best Open-Source Tools for SNMP Monitoring & IoT: ThingsBoard, Zabbix, and More

Why Open Source for SNMP & IoT?

Commercial monitoring and IoT platforms can cost thousands per year in licensing alone. Open-source alternatives have matured significantly — many now rival or exceed proprietary tools in features, scalability, and community support.

In this post, I'll walk you through the best open-source tools I use and recommend for SNMP-based network monitoring and IoT device management.

IoT Platforms

ThingsBoard — The Complete IoT Platform

ThingsBoard is one of the most powerful open-source IoT platforms available today. It handles device management, data collection, processing, and visualization — all in one package.

Why ThingsBoard Stands Out

• Multi-protocol support — MQTT, HTTP, CoAP, LwM2M, and SNMP out of the box
• Rule engine — Visual drag-and-drop rule chains for data processing, alerting, and device RPC
• Real-time dashboards — Build rich, interactive dashboards without writing frontend code
• Multi-tenancy — Perfect for managed service providers or large organizations
• Device provisioning — Bulk device onboarding with auto-provisioning profiles
• Edge computing — ThingsBoard Edge for local data processing at remote sites

Quick Setup with Docker

Getting started with ThingsBoard is straightforward:

# Pull and run ThingsBoard CE (Community Edition)
docker run -it -p 9090:9090 -p 7070:7070 \
  -p 1883:1883 -p 5683-5688:5683-5688/udp \
  -v tb-data:/data \
  -v tb-logs:/var/log/thingsboard \
  --name thingsboard \
  --restart always \
  thingsboard/tb-postgres

Default access: http://localhost:9090 (login: tenant@thingsboard.org / tenant)

SNMP Integration in ThingsBoard

ThingsBoard can act as an SNMP manager, polling network devices directly:

1. Navigate to Device Profiles → Create a new profile with transport type SNMP
2. Define your SNMP communication config — set the community string, version (v1/v2c/v3), and polling period
3. Add OID mappings — map SNMP OIDs to ThingsBoard telemetry keys
4. Create devices using this profile and assign device IP addresses

Example OID mappings for a network switch:

| ThingsBoard Key | SNMP OID | Description | |----------------|----------|-------------| | sysUptime | 1.3.6.1.2.1.1.3.0 | Device uptime | | cpuUsage | 1.3.6.1.4.1.9.9.109.1.1.1.1.3.1 | CPU utilization (Cisco) | | ifInOctets | 1.3.6.1.2.1.2.2.1.10 | Incoming traffic | | ifOutOctets | 1.3.6.1.2.1.2.2.1.16 | Outgoing traffic |

This means you can monitor both IoT sensors and network infrastructure from a single platform.

ThingsBoard Rule Engine — Real Power

The rule engine is where ThingsBoard truly shines. You can build processing pipelines visually:

• Filter — Route data based on device type, telemetry values, or metadata
• Transform — Convert units, calculate deltas, aggregate data
• Action — Send alerts (email, SMS, Slack), trigger device commands, save to database
• External — Forward data to Kafka, RabbitMQ, or REST APIs

Example: If a switch port utilization exceeds 80%, ThingsBoard can automatically send an alert and log the event — no custom code required.

Other Notable IoT Platforms

Node-RED

Node-RED is a flow-based programming tool built on Node.js, ideal for wiring together IoT devices, APIs, and services.

• Visual flow editor in the browser
• Huge library of community nodes (MQTT, Modbus, OPC-UA, HTTP, databases)
• Lightweight — runs on a Raspberry Pi
• Great for prototyping and edge processing

Node-RED pairs well with ThingsBoard — use Node-RED at the edge for local processing and ThingsBoard as the central platform.

Chirpstack — LoRaWAN Network Server

If you're building LoRaWAN IoT deployments, ChirpStack is the go-to open-source network server:

• Full LoRaWAN network server stack
• Device management and provisioning
• Integration with MQTT, HTTP, and cloud platforms
• Supports Class A, B, and C devices

SNMP Monitoring Tools

Zabbix — Enterprise-Grade Monitoring

Zabbix is a mature, feature-rich open-source monitoring platform with excellent SNMP support.

Key Strengths

• Auto-discovery — Automatically find and add devices using SNMP discovery rules
• Template system — Pre-built templates for thousands of devices (Cisco, MikroTik, HP, Dell, etc.)
• SNMPv3 support — Full authentication and encryption
• SNMP trap receiver — Receive and process SNMP traps natively
• Calculated items — Derive bandwidth utilization from raw counter OIDs
• Scalable — Monitor 100,000+ metrics with proxy architecture

Quick SNMP Host Setup

# Install Zabbix agent is not needed for SNMP-only devices
# Just configure SNMP interfaces in the Zabbix frontend

# Test SNMP connectivity first
snmpwalk -v2c -c public 192.168.1.1 sysDescr

In Zabbix, create a host with an SNMP interface, assign a template (e.g., "Template Net Cisco IOS SNMPv2"), and monitoring begins automatically.

LibreNMS — Auto-Discovering Network Monitor

LibreNMS is built specifically for network monitoring with SNMP at its core.

What Makes LibreNMS Great

• Automatic discovery — Point it at a subnet and it finds everything
• Extensive device support — 1000+ device types out of the box
• Weathermap — Visual network topology maps
• Alerting — Flexible rules with multiple transport options (email, Slack, PagerDuty, Telegram)
• API — Full REST API for integration
• Community MIBs — Constantly updated device support

LibreNMS is ideal if your primary focus is network infrastructure monitoring and you want something that works with minimal configuration.

Prometheus + SNMP Exporter

For teams already using the Prometheus ecosystem:

# snmp_exporter config snippet
modules:
  if_mib:
    walk:
      - 1.3.6.1.2.1.2       # interfaces
      - 1.3.6.1.2.1.31.1.1  # ifXTable
    metrics:
      - name: ifHCInOctets
        oid: 1.3.6.1.2.1.31.1.1.1.6
        type: counter

The SNMP Exporter translates SNMP data into Prometheus metrics, which you can then visualize in Grafana and alert on with Alertmanager.

The Glue: MQTT Brokers & Visualization

Eclipse Mosquitto — MQTT Broker

Every IoT stack needs a reliable MQTT broker. Mosquitto is lightweight, fast, and rock-solid:

# Run Mosquitto with Docker
docker run -it -p 1883:1883 -p 9001:9001 \
  -v mosquitto-config:/mosquitto/config \
  -v mosquitto-data:/mosquitto/data \
  eclipse-mosquitto

ThingsBoard includes its own MQTT broker, but Mosquitto is useful for edge deployments or standalone setups.

Grafana — Dashboards for Everything

Grafana connects to virtually any data source and builds beautiful dashboards:

• Supports Prometheus, InfluxDB, PostgreSQL, MySQL, Zabbix, and more
• Pre-built dashboards available on Grafana.com
• Alerting with contact points (email, Slack, PagerDuty, webhooks)
• Dashboard variables for dynamic filtering

Grafana is the ideal visualization layer on top of Zabbix, Prometheus, or ThingsBoard data.

My Recommended Stack

For a complete open-source SNMP + IoT monitoring setup, here's what I recommend:

| Layer | Tool | Purpose | |-------|------|---------| | IoT Platform | ThingsBoard | Device management, IoT data collection, rule engine | | SNMP Monitoring | Zabbix or LibreNMS | Network device monitoring, SNMP polling/traps | | MQTT Broker | Mosquitto (or ThingsBoard built-in) | IoT message transport | | Edge Processing | Node-RED | Local data processing and protocol bridging | | Visualization | Grafana | Unified dashboards across all data sources | | LoRaWAN | ChirpStack | Long-range IoT device connectivity |

How They Work Together

1. IoT sensors publish telemetry via MQTT to ThingsBoard
2. Network devices are polled via SNMP by Zabbix/LibreNMS
3. ThingsBoard rule engine processes IoT data, triggers alerts, and forwards to external systems
4. Grafana pulls data from both ThingsBoard and Zabbix for unified dashboards
5. Node-RED handles edge processing and protocol translation at remote sites

This gives you a complete, production-ready monitoring ecosystem — entirely open source.

Getting Started

If you're new to this stack, I'd suggest starting in this order:

1. Set up ThingsBoard with Docker — connect a test device via MQTT
2. Install Zabbix — add your first network switch via SNMP
3. Connect Grafana to both platforms for a unified view
4. Build rule chains in ThingsBoard for automated alerting

Each of these tools has excellent documentation, and I'll be covering detailed setup guides for each in upcoming posts.

Have questions about setting up any of these tools? Check out our Services page — we offer professional setup and consulting for open-source monitoring stacks.