What Is Blynk 2.0?
Blynk is an IoT platform that lets you connect a microcontroller such as an ESP32 to the internet and control it from a phone or a web browser, without running a server of your own. Your board sends readings (temperature, soil moisture, motion) to Blynk's cloud, and you see them on a dashboard made of switches, gauges and charts. In the other direction, a tap on a switch on your phone travels through the cloud to your board and turns a relay or an LED on.
"Blynk 2.0" is the name many tutorials use for the current version of the platform, as opposed to the older Blynk Legacy. If you follow a guide written for Blynk Legacy, the menus and steps will not match what you see today, so always check which version a tutorial covers. Everything below describes the current platform: Blynk.Cloud, Blynk.Console and the Blynk.Apps mobile app.
This article explains the ideas you need before you write any code: the parts of the platform, what a template, device, datastream and dashboard really are, what the free plan allows, and when Blynk is a better fit than MQTT, Node-RED or Home Assistant. The next article, Getting Started with Blynk 2.0 on ESP32, puts it all into practice.
The Four Parts of Blynk
Blynk is not one program but four pieces that work together:
| Part | What it is | What you use it for |
|---|---|---|
| Blynk.Cloud | The hosted servers | Stores your data and passes messages between your board and your apps |
| Blynk.Console | A web application | Creating templates, adding devices, building dashboards and monitoring them remotely |
| Blynk.Apps | A native iOS and Android app | Controlling and viewing your devices from a phone |
| Blynk library | An Arduino library | Runs on your ESP32 or ESP8266 and talks to Blynk.Cloud |
You do most of the setup in Blynk.Console on a computer, write a short sketch with the Blynk library, and then use either the web dashboard or the phone app to interact with the board.
The Four Core Concepts
Almost every Blynk question comes back to these four words. Once they make sense, the console stops feeling confusing.
Template
A template is a set of configurations: which datastreams exist, how the dashboard looks, which events can fire, and what extra information (metadata) each device carries. Think of it as a blueprint. You create it once, and every device you create from it inherits the same settings. If you build ten identical sensor nodes, you make one template and ten devices.
In Blynk.Console, templates live under Developer Zone → My Templates. A template has tabs for Info, Datastreams, Metadata, Events and Web Dashboard.
Device
A device is one real board, created from a template. It is identified by an auth token, a unique identifier generated by Blynk.Cloud. You paste the token (along with the template ID) into your sketch, and that is how the cloud knows which board is talking.
Treat the auth token like a password. Anyone who has it can send data as your device.
Datastream
A datastream is a channel that carries one kind of data between your device and Blynk.Cloud. It is the Blynk counterpart of a virtual pin. You define each datastream in the template with:
- a name (for example "LED Switch"),
- a virtual pin number (V0, V1, V2 and so on),
- a data type (integer, double or string), and
- a minimum and maximum value.
A virtual pin has no physical pin on the board. It is just a numbered channel. Your sketch decides what happens when a value arrives on V0, for example switching GPIO 2, and the dashboard decides how that value is shown.
| Datastream | Virtual pin | Data type | Range | Typical use |
|---|---|---|---|---|
| LED Switch | V0 | Integer | 0 – 1 | A switch that turns an output on or off |
| Temperature | V1 | Double | -40 – 125 | A gauge showing a sensor reading |
| Status text | V2 | String | n/a | A label showing a message from the board |
Dashboard
A dashboard is the screen you interact with. It is built from widgets such as switches, gauges, labels and charts, and each widget is linked to a datastream. The layout is stored in the template.
One thing catches almost every beginner: the web dashboard and the mobile dashboard are separate. They do not automatically mirror each other, so a widget you add in Blynk.Console will not appear in the phone app until you add it there too.
Widgets You Will Use Most
The web dashboard offers a long list of widgets. These are the ones beginners reach for first:
| Widget | What it does |
|---|---|
| Switch | Sends an on/off value to your board |
| Level Slider | Sends a number within a range, for example a brightness value |
| LED | Shows an on/off or brightness state from the board |
| Value Display / Labeled Value | Shows a number or text sent by the board |
| Gauge / Radial Gauge / Enhanced Gauge | Shows a number against a minimum and maximum, ideal for temperature or humidity |
| Simple Chart / SuperChart | Plots values over time |
| LCD | Shows text as if it were a small display |
| Terminal | A text console between you and the board |
| Video Stream | Shows a video feed |
On the free plan the Terminal is cleared every time the app refreshes, so do not rely on it to keep a log.
A Worked Example: Designing a Plant Monitor Template
Here is how the four concepts come together in a real project. Imagine a small ESP32 that watches a plant and can switch a watering pump. Before touching any code, you would plan the template like this.
Datastreams (the channels between the board and the cloud):
| Name | Virtual pin | Data type | Range | Direction |
|---|---|---|---|---|
| Soil Moisture | V0 | Integer | 0 – 100 | Board to dashboard |
| Air Temperature | V1 | Double | 0 – 50 | Board to dashboard |
| Pump | V2 | Integer | 0 – 1 | Dashboard to board |
| Status | V3 | String | n/a | Board to dashboard |
Dashboard widgets (linked to those datastreams):
- a Gauge for Soil Moisture (V0),
- a second Gauge for Air Temperature (V1),
- a Switch for the Pump (V2),
- a Labeled Value for Status (V3), and
- a SuperChart for the moisture history, which on the free plan covers the last week.
Event: one event called something like "Soil too dry", so the dashboard can notify you. The free plan includes 5 events, so spend them on alerts that matter.
Four datastreams out of the 50 the free plan allows per template is a very small footprint. The design takes a few minutes, and it makes the code easy to write afterwards, because every Blynk.virtualWrite() and BLYNK_WRITE() in the sketch maps to a row in this table. The same planning step works for any project you build with Blynk.
What the Free Plan Allows
These figures come from Blynk's pricing page and its limits documentation, as checked in October 2026.
| Limit | Free plan |
|---|---|
| Devices | 5 |
| Users | 1 |
| Device messages | 100,000 per month |
| Data retention | 1 week |
| Datastreams per template | 50 |
| Templates | 10 |
| Events and notifications | 5 |
| Multi-device dashboards | 1 |
| HTML widgets | 1 |
| Cloud automations | 5 |
| Webhooks | 1 |
| OTA firmware update campaigns | 2 |
Features that are not on the free plan include bulk OTA updates, SMS notifications and role-based dashboard access.
💡 Tip
Plan limits change over time. Older forum posts and tutorials quote different numbers for datastreams, templates and messages, so confirm the current figures on Blynk's pricing page before you plan a project around them.
What This Means in Practice
- 5 devices is enough for a handful of ESP32 projects, but not for a whole house of sensor nodes.
- 100,000 messages per month is the limit that surprises people. If every value your board sends counts as one message, a reading every 10 seconds from a single device comes to roughly 259,000 messages a month, while one every 30 seconds is about 86,000. Send only as often as you really need, and check how Blynk counts messages before you design a data logger around it.
- 1 week of data retention means charts only reach back seven days. If you need long-term history, you need a paid plan or a different tool.
What You Get on the Paid Plans
If the free plan feels tight, Blynk's paid plans raise the limits. These figures are from Blynk's pricing page as checked in October 2026.
| Free | Starter | Prototype | Production | |
|---|---|---|---|---|
| Price | $0 | $29 per month | $99 per month | $199 to $1,099 per month |
| Devices | 5 | 10 | 50 | 100 to 1,000 |
| Users | 1 | 1 | 50 | 100 to 1,000 |
| Data retention | 1 week | 1 month | 6 months | 12 months |
| Device messages per month | 100,000 | 10 million | Unlimited | Unlimited |
An Enterprise tier with custom pricing sits above these. For a hobby project the free plan is usually enough. The first limit most people hit is messages or retention, not devices, and the jump from free to Starter is mainly about those two.
Limits That Affect Your Code
Besides the plan limits, Blynk enforces rate limits that shape how you write your sketch:
| Limit | Value |
|---|---|
| Real-time dashboard updates | 20 commands per second |
| Requests from one device | 50 per second |
| Values sent by the board | More than about 10 per second can cause a Flood Error and a disconnect |
Blynk.logEvent() | 100 events per day per device, at least 1 second apart for the same event |
| Notifications (push, email) | At least 5 seconds apart |
| Largest string value | 1024 bytes |
The practical rules for firmware follow directly from these:
- Never call
Blynk.virtualWrite()or any otherBlynk.*function directly insideloop(). It runs thousands of times a second and floods the server. - Schedule your sends with
BlynkTimer, for example one reading every few seconds. - Avoid long
delay()calls. They can break the connection. The Getting Started guide usesBlynkTimerfor this reason.
Blynk vs MQTT, Node-RED and Home Assistant
Blynk is one of several ways to get your board onto a dashboard. The right choice depends on how much setup you want and who owns the data.
| Blynk | MQTT + Node-RED | Home Assistant | |
|---|---|---|---|
| Where it runs | Hosted by Blynk | Your own broker and server, for example a Raspberry Pi | Your own server |
| Setup effort | Low: account, template, sketch | Medium: install a broker and Node-RED | Medium to high |
| Phone app | Ready-made | You build a dashboard that opens in the browser | Its own app |
| Limits | Free plan caps on devices and messages | Limited only by your hardware | Limited only by your hardware |
| Works without internet | No, it needs the cloud | Yes, on your local network | Yes, on your local network |
| Best for | Quick projects and demos you want on a phone in an evening | Learning how IoT really works and projects that must stay local | Whole-home automation |
A fair rule of thumb: pick Blynk when you want a working phone dashboard quickly, and pick MQTT when you want full control, no message caps and local operation. If you want to understand what happens underneath, read our ESP32 MQTT tutorial.
When Blynk Is Not the Right Choice
Blynk is a good fit for quick projects, but it is not the best tool for everything. Look elsewhere if:
- The project must work without internet. Blynk needs its cloud, so a lost connection means no control and no dashboard. A local setup with MQTT or Home Assistant keeps working on your own network.
- You need long history. The free plan keeps one week of data, and even the paid plans stop at 12 months of retention on Production. If you want years of readings, store them yourself.
- You send data very fast. Blynk is built for readings every few seconds, not hundreds per second. Sending more than about 10 values per second can trigger a Flood Error and a disconnect.
- Your data must stay on your own hardware. With Blynk, your readings live in Blynk's cloud. If privacy or ownership matters, self-host.
- You are building something safety-critical. A cloud switch should never be the only thing standing between a person and a hazard, for example a heater, a lock or a pump that could flood a room. Add local protection in hardware or firmware.
- You plan a large fleet on a small budget. Five free devices go quickly, and the paid plans are priced for products, not hobby boards.
For most beginner and prototype projects none of these apply, and Blynk's speed of setup is the deciding factor.
Common Beginner Mistakes
- Following a Blynk Legacy tutorial. If the screenshots show a different console, the guide is for the old platform.
- Forgetting Developer Mode. You can only create and edit templates while Developer Mode is switched on in your profile.
- Treating a virtual pin like a GPIO pin. V0 is not pin 0. It is a channel you map to a real pin in code.
- Expecting the web and phone dashboards to match. They are built separately.
- Sending data from
loop()without a timer. It floods the server and gets the device disconnected. - Using a 5 GHz Wi-Fi network. The ESP32 connects to 2.4 GHz networks only.
⚠️ Warning
Never publish a sketch that contains a real auth token or Wi-Fi password. Screenshots, forum posts and GitHub repositories are the usual places they leak. If a token is exposed, treat that device as compromised, create a replacement device and flash it with the new token.
Frequently Asked Questions
Is Blynk free? Yes, there is a free plan, with the limits listed above. Paid plans raise the limits.
Do I need my own server? No. Blynk.Cloud is hosted for you, which is the main reason it is quick to start with.
Which boards work with Blynk? The Blynk library supports ESP32 and ESP8266 boards, among others. This series uses the ESP32.
Can I control a board from my phone and from a browser? Yes. Build the web dashboard in Blynk.Console and the mobile dashboard in the Blynk app. Both talk to the same device through the same datastreams.
Is Blynk better than MQTT? Neither is better in general. Blynk is faster to start with, while MQTT gives you more control and no message caps.
Next Step
Now that the vocabulary is clear, build something real: Getting Started with Blynk 2.0 on ESP32 takes you from creating an account to a board that shows as Online and responds to a switch on your dashboard.