DEV Community: Adrelien

How to Visualize The Things Network Data in Grafana (Real-Time & Easy)

Adrelien — Wed, 10 Dec 2025 23:23:12 +0000

You've deployed LoRaWAN sensors. They're transmitting to The Things Network perfectly. But here's where most people get stuck: turning that raw sensor data into actual dashboards you can use. If you've searched for "The Things Network Grafana visualization" or "how to store TTN data," you've probably found tutorials that require setting up InfluxDB, configuring Telegraf with MQTT, wrestling with Docker containers, or paying for Azure IoT Hub. Hours of configuration, multiple moving parts that can break, and the constant burden of maintenance.

There's a simpler path. Telemetry Harbor's TTN integration connects your LoRaWAN data to production-ready Grafana dashboards in under 10 minutes. One webhook, zero infrastructure, and your sensor data starts flowing immediately with RSSI, SNR, and network quality metrics automatically included.

The Storage Problem Nobody Talks About

The Things Network receives your data perfectly, but it only stores it for seven days. After that, it's gone. This puts you in an impossible position: either build custom storage infrastructure yourself, or lose all your historical sensor data. Most tutorials gloss over this critical gap, jumping straight to visualization while ignoring the fundamental question of where your data actually lives long-term.

Setting up your own database means installing InfluxDB or PostgreSQL, configuring retention policies, managing disk space, implementing backups, monitoring database health, and keeping everything secure and patched. Cloud alternatives like Azure IoT Hub or AWS IoT Core solve the storage problem but introduce new challenges: complex configuration interfaces, data ingestion fees, storage costs that scale with usage, and the expertise needed to manage cloud infrastructure properly.

What you actually need to get started

LoRaWAN device sending data to The Things Network
The Things Network V3 account (free tier works perfectly)
Telemetry Harbor account (free tier: 1 request/second, 3 million data points, plus 10 AI questions daily)
10 minutes of your time

No Docker installation. No database configuration. No cloud platform expertise required.

Why Telemetry Harbor is Different

Instead of making you become a DevOps engineer just to see your sensor data, Telemetry Harbor provides a dead-simple webhook integration:

Zero Infrastructure: No servers to provision, no databases to configure, no Docker networks to debug
Instant Grafana Access: Pre-configured Grafana instance included with every harbor
Automatic Payload Decoding: Your TTN payload formatter runs in TTN; Telemetry Harbor automatically ingests the decoded result
Network Metrics Included: RSSI, SNR, spreading factor, frequency, all captured automatically for every uplink
Actually Free (for real): 1 request/second (86,400 requests per day), which means a 20-sensor fleet transmitting every 10 minutes uses only 2,880 of your daily quota

Compare that to self-hosting: a basic DigitalOcean droplet starts at $6/month, plus your own setup and maintenance time. Azure or AWS? Their managed time-series databases start at $23/month, before data transfer and storage fees.

But wait, what if you want full control over your data?

Telemetry Harbor also comes with a free, fully open-source, self-hosted version. Run it on your own hardware, Raspberry Pi, mini-PC, NAS, home server, whatever you have. Get the OSS version here: Overview | Telemetry Harbor

Telemetry Harbor OSS is the open-source ingestion and visualization stack behind Telemetry Harbor.

Step 1: Create Your TTN Harbor (2 minutes)

Log into Telemetry Harbor and create a new harbor:

Click Create Harbor
Name it something like "Field_Sensors" or "LoRaWAN_Fleet"
Select The Things Network as the Harbor Type (not "General")
Choose Free tier to start
Click Create Harbor

From the harbor details page, copy these credentials (you'll need them in a minute):

From API Access tab:

TTN Webhook Endpoint (e.g., https://telemetryharbor.com/api/v2/ingest/123/ttn)
API Key

From Visualization tab:

Grafana URL
Grafana Username
Grafana Password

Step 2: Configure Your Payload Formatter (5 minutes)

Here's the one technical requirement: your TTN payload formatter must return flat, numerical data. This runs on TTN's servers (not yours), and Telemetry Harbor automatically ingests the decoded result.

Why This Matters

LoRaWAN devices send raw bytes to save battery and bandwidth. TTN needs to decode these bytes into meaningful numbers before sending to integrations. Without this step, Telemetry Harbor would receive 0x1850 instead of temperature: 24, humidity: 80.

Write Your Decoder

In your TTN Console:

Go to Applications → Your Application → Payload Formatters → Uplink
Select Javascript
Paste your decoder function

Example for a basic environmental sensor:

function decodeUplink(input) {
  var bytes = input.bytes;
  var data = {};

  // Decode temperature (2 bytes, signed, 0.01°C precision)
  var temp_raw = (bytes[0] << 8) | bytes[1];
  if (temp_raw > 32767) temp_raw -= 65536;
  data.temperature = temp_raw / 100.0;

  // Decode humidity (1 byte, 0-100%)
  data.humidity = bytes[2];

  // Decode battery (1 byte, 0.01V precision)
  data.battery_voltage = bytes[3] / 100.0;

  return {
    data: data,        // MUST be flat numerical values
    warnings: [],
    errors: []
  };
}

Test it: Use the Test tab with sample hex payload to verify output, then click Save.

💡 Pro Tip: Keep your payload formatters simple. Complex nested objects won't work. Just flat keys with numerical values.

Step 3: Add the Webhook to TTN (3 minutes)

This is where the magic happens. No MQTT clients, no Telegraf configs, no debugging connection strings.

In your TTN Application:

Go to Webhooks → + Add Webhook
Select Custom Webhook
Configure exactly as shown:
- Webhook ID: telemetry-harbor
- Webhook Format: JSON
- Base URL: Paste your TTN Webhook Endpoint from Step 1
- Additional Headers:
  - Key: X-API-Key
  - Value: Your Telemetry Harbor API Key
- Enabled Messages:
  - ✅ Uplink message (required)
  - ❌ Uncheck everything else
Click Add webhook

That's the entire setup. No Docker compose files, no environment variables, no service restarts. Your data is now flowing.

Step 4: Check Your Grafana Dashboard

Open your Grafana Endpoint URL, log in with your credentials, and navigate to Dashboards → Comprehensive Telemetry Dashboard.

Use the filter controls to focus on specific aspects of your deployment. Select your TTN harbor as the data source, filter by Ship ID to view specific devices, choose Cargo IDs to display particular metrics, and adjust time ranges to see historical patterns. The interface makes it simple to zoom into problem areas or zoom out for fleet-wide analysis.

For custom visualizations beyond the default dashboard, create panels tailored to your monitoring needs.

The Telemetry Harbor Advantage: Harbor AI

This is where Telemetry Harbor goes beyond "just another dashboard platform." Harbor AI lets you ask questions about your LoRaWAN fleet in plain English.

Example Conversations

You: "Which sensors have the weakest signal right now?"

Harbor AI: "Based on the last hour of RSSI data:

soil-sensor-03: -118 dBm (critical, likely dropping packets)
field-monitor-07: -112 dBm (weak but stable)
All other devices: -95 dBm or better

Sensor-03's signal has degraded 15 dBm since Monday. Consider relocating the gateway or adding a repeater."

Harbor AI combines your specific sensor data with general LoRaWAN knowledge to provide insights you'd otherwise need to piece together manually from multiple Grafana panels.

Conclusion

LoRaWAN sensors should simplify monitoring, not create infrastructure problems. The path from TTN to actionable dashboards has traditionally required database expertise, DevOps skills, or cloud platform knowledge that most sensor deployments don't need and shouldn't require.

Telemetry Harbor changes this equation by treating TTN integration as a solved problem rather than a DIY project. One webhook connects your entire LoRaWAN fleet to production-grade storage and visualization. Your data flows continuously, dashboards update in real-time, and network quality metrics appear automatically alongside your sensor readings. No infrastructure to manage, no cloud bills to monitor, no maintenance windows to schedule.

The comprehensive Grafana dashboard displays your data immediately without requiring panel configuration or query building. Harbor AI answers questions about your fleet in plain language without requiring dashboard expertise. Network quality metrics help optimize gateway placement and diagnose connectivity issues without specialized LoRaWAN tools.

Ready to Get Started?

Create a free Telemetry Harbor account, configure the TTN webhook, and see your first data in under 10 minutes. The free tier handles real deployments at zero cost, and paid plans remain dramatically cheaper than cloud alternatives if you need to scale. Your LoRaWAN data deserves better than DIY infrastructure projects or expensive cloud platforms. Choose the simple path.

How to Push, Store, and Visualize IoT Data to the Cloud (No Self-Hosting Required)

Adrelien — Sat, 21 Dec 2024 17:16:58 +0000

In the world of IoT, we often find ourselves searching for efficient ways to get data from sensors to a place where it can be stored and visualized. IoT devices generate massive amounts of telemetry data, but managing this data effectively is often more complex than it seems.

Typically, setting up an infrastructure involves multiple components: an MQTT broker for data ingestion, a service like Node-RED to process and save the data, a database such as InfluxDB for storage, and a visualization tool like Grafana. Many IoT enthusiasts and professionals end up self-hosting these components on a server or in a homelab. However, this approach frequently leads to spending more time configuring and maintaining the setup rather than building devices, expanding sensor networks, or analyzing data to take action.

This guide focuses on an efficient way to tackle these challenges using Telemetry Harbor. By the end, you’ll understand how to push your IoT data to the cloud and visualize it effortlessly—without the need to self-host or configure complex infrastructures.

The Problem

IoT enthusiasts often struggle with the complexity of setting up systems to collect, store, and visualize telemetry data. The process typically involves configuring tools like MQTT brokers, databases, and visualization platforms, which requires technical expertise and significant time investment. Setting up data ingestion servers, whether using MQTT or HTTP, can be a complicated and time-consuming task. After that, choosing the right database—such as a time-series database like InfluxDB or TimescaleDB or a general-purpose solution like PostgreSQL—adds another layer of complexity. Once the database is set up, creating dashboards with tools like Grafana involves connecting the database, designing visualizations, and managing user access. But the challenges don’t end there.

Maintaining a self-hosted system comes with ongoing responsibilities such as updates, backups, and scaling, which only become more demanding as data volumes increase. This leads to high operational costs for hosting and infrastructure, which can grow quickly as projects scale. Enthusiasts often find themselves spending more time on managing the infrastructure than on innovating or deploying devices, which can be frustrating and divert attention away from the core goals of IoT development.

Simplify Everything with Telemetry Harbor

Telemetry Harbor is a platform that provides a complete full-stack solution as a service. From ingesting data through an easy-to-use HTTP endpoint (with more protocols coming soon) to storing it in a well-optimized, managed database, and offering pre-configured Grafana templates for visualization, Telemetry Harbor streamlines the entire process. In just a few minutes, you can go from creating an account to visualizing your first data point—no complex setup or infrastructure management required.

Not sold yet? Telemetry Harbor has rolled out the beta of Harbor AI, where you can interact with your data using a large language model—essentially, you can talk to your data in your natural language. No need to create complex Grafana dashboards for a simple value; just ask your Harbor. While this feature is still in beta, every user has a maximum of 10 questions per day.

They offers a generous free tier that makes it easy to get started without any upfront costs. With the free plan, you'll get 10 requests per second, 1 batch request per second, and up to 10 data points per batch. Your data is retained for 30 days, and you’ll have unlimited storage and shared access to Grafana. While the free tier includes basic backup and support, it’s a great way to explore the platform's capabilities. As your needs grow, you can easily scale up. For more details on the free plan and other pricing options, check out our pricing page.

Getting Started with Telemetry Harbor

Let’s walk through how to get started and push your first data point to Telemetry Harbor. We’ll follow the official documentation, and you can always check the latest guide here: Getting Started Guide.

Step 1: Create Your Account

Go to the Sign Up page.
Fill in your details and create your account.
Check your inbox for a verification email.
Click the verification link to activate your account.
After activation, log in to your account.
Now, head to the Harbor Page.

Step 2: Set Up Your Harbor

In the top right corner, click on Create Harbor.
Give your harbor a name.
Choose the harbor type. For now, select the general type (custom types like GPS or temperature data will be added soon).
Choose your Harbor Specifications. If you want to use the free tier, select Free.
Click Create Harbor to finish setting up your harbor.
After creating your harbor, the harbor list will update, and you’ll see your new harbor listed.
Click View Details to access essential information like the API Endpoint, API Batch Endpoint, API Key, Grafana Endpoint, Grafana Username, and Grafana Password.

Step 3: Get Your API Key and Endpoint

Find the API Endpoint (make sure to use the standard endpoint, not the batch one, since we’re sending just one data point).
Copy the API Key and API Endpoint. Keep these handy for the next step.

Step 4: Push Your First Data Point

To send your first data point, you’ll need to make a POST request to the API endpoint.

Include the header: X-API-Key: your_api_key_here.
Structure the POST body like this: { "time": "2024-11-18T19:24:00.948Z", "ship_id": "string", "cargo_id": "string", "value": 0 } You can use curl or any programming language/tool that can send POST requests. Here’s an example using curl:

curl -X POST https://telemetryharbor.com/api/v1/ingest/ingest/harbor_id \ -H "X-API-Key: your_api_key" \ -H "Content-Type: application/json" \ -d '{ "time": "2024-11-18T19:44:16.160Z", "ship_id": "string", "cargo_id": "string", "value": 0 }'
If everything goes smoothly, you should get a code 200 response, confirming that your data has been received.

Step 5: View Your Data

Go back to the Harbor Details page.
Copy the Grafana Password and open the Grafana Endpoint.
Log in using your Grafana Username (this will be the same as your Telemetry Harbor email) and the Grafana Password.
Once logged in, go to Dashboards **and select the **Comprehensive Telemetry Dashboard (this is the demo dashboard provided by Telemetry Harbor).
Inside the dashboard: Choose your data source (which will be your harbor). Use the filters to view data based on ship_id and cargo_id.

From there, you'll find several panels in the dashboard, and you're free to customize them or even create entirely new ones to suit your needs. If you scroll down, you'll also see a map. This is because, even with the general harbor type, you can push GPS coordinates to visualize location data. While the process for doing this is a bit unconventional, the documentation provides clear and detailed instructions on how to handle it effectively. For more information, check out the official guide on working with GPS data at Telemetry Harbor GPS Data API Documentation.

Key Concepts

Harbors: These are logical containers that organize your data into manageable groups, making it easier to analyze.
Ships: These represent individual devices or data sources that send data to your harbors.
Cargo: The sensors or devices on your ships that capture and send the data.
ship_id and cargo_id: These values can be any string. It’s important to stick to a consistent naming scheme to ensure proper grouping and filtering when analyzing data in your dashboards.

In conclusion, Telemetry Harbor takes the complexity out of managing IoT data by providing a seamless, cloud-based solution for data collection, storage, and visualization. This enables you to focus on what truly matters—your devices and the insights they generate—rather than dealing with the technicalities of infrastructure setup. With just a few simple steps, you can start pushing data to the cloud and viewing it in a pre-configured Grafana dashboard, eliminating the need for extensive configuration or maintenance. The free tier offers an accessible way to get started. This approach allows you to spend more time innovating with your devices and less time managing the systems that support them