ESP32 With MySQL Database Management: Read & Write

In the world of IoT, data is everything — from monitoring environmental sensors to tracking smart home devices.
But where does all that data go? How do you store, organize, and access it efficiently?

That’s where MySQL database integration comes in.
In this project, we’ll learn how to connect an ESP32 Wi-Fi board with a MySQL database to perform read and write operations — sending sensor data to the database and fetching stored records back to the ESP32.

This tutorial gives you the complete architecture, setup process, and code explanation step-by-step.
It’s perfect for beginners and intermediate IoT developers who want to move beyond simple Blynk or Firebase projects and start using real databases for industrial-grade IoT applications.

🚀 2. Project Overview

This project demonstrates how to:

Connect ESP32 to a local or online MySQL database
Use HTTP (POST & GET) methods for data exchange
Log sensor readings (like temperature or humidity)
Retrieve stored data dynamically
Display it on a web dashboard or serial monitor

🧩 Core Workflow

[Sensor Data] → [ESP32] → [PHP Script] → [MySQL Database] → [Web Dashboard or App]

💡 Tip: Using PHP as a middleware helps maintain data integrity and security between the ESP32 and the database.

🔧 3. Components Required

Component	Quantity	Description
ESP32 Development Board	1	WiFi + BLE enabled microcontroller
DHT11 / DHT22 Sensor	1	Measures temperature & humidity
Jumper Wires	—	For circuit connections
Breadboard	1	Easy prototyping
Micro USB Cable	1	Power and programming
Computer / Server	1	Hosts MySQL and PHP scripts

💻 Software Requirements

Arduino IDE
PHP Server (XAMPP / WAMP / LAMP)
MySQL Database
Browser for dashboard testing

🔌 4. Circuit Connection

The wiring is simple and straightforward.

DHT Sensor Pin	ESP32 Pin
VCC	3.3V
DATA	GPIO 4
GND	GND

You can replace DHT11 with any other sensor — like soil moisture, light sensor (LDR), or ultrasonic — depending on your project goal.

🌍 5. Setting Up the MySQL Database

Now that our hardware is ready, it’s time to prepare the database for storing the sensor data.

⚙️ Step 1: Open phpMyAdmin

Launch XAMPP Control Panel
Start Apache and MySQL
Open your browser and go to:
👉 http://localhost/phpmyadmin

⚙️ Step 2: Create Database

Click on New → Name your database

iot_esp32_db

⚙️ Step 3: Create Table

SQL Query:

CREATE TABLE sensor_data (
  id INT(6) UNSIGNED AUTO_INCREMENT PRIMARY KEY,
  temperature FLOAT,
  humidity FLOAT,
  reading_time TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
);

This table will store temperature and humidity data from the ESP32 along with timestamps.

🌐 6. Creating PHP Scripts for Data Communication

To communicate between ESP32 and MySQL, we’ll create two PHP scripts:

🧩 a) write_data.php

Used for inserting sensor data into the database.

<?php
$servername = "localhost";
$username = "root";
$password = "";
$dbname = "iot_esp32_db";

$conn = new mysqli($servername, $username, $password, $dbname);

if ($conn->connect_error) {
  die("Connection failed: " . $conn->connect_error);
}

$temp = $_GET['temperature'];
$hum = $_GET['humidity'];

$sql = "INSERT INTO sensor_data (temperature, humidity) VALUES ('$temp', '$hum')";

if ($conn->query($sql) === TRUE) {
  echo "Data Inserted Successfully";
} else {
  echo "Error: " . $sql . "<br>" . $conn->error;
}

$conn->close();
?>

📁 Save this file as write_data.php inside your htdocs folder (XAMPP directory).

🧩 b) read_data.php

Used for fetching data back from the database.

<?php
$servername = "localhost";
$username = "root";
$password = "";
$dbname = "iot_esp32_db";

$conn = new mysqli($servername, $username, $password, $dbname);

if ($conn->connect_error) {
  die("Connection failed: " . $conn->connect_error);
}

$sql = "SELECT * FROM sensor_data ORDER BY id DESC LIMIT 5";
$result = $conn->query($sql);

if ($result->num_rows > 0) {
  while($row = $result->fetch_assoc()) {
    echo "Temp: " . $row["temperature"]. " °C | Humidity: " . $row["humidity"]. " % | Time: " . $row["reading_time"]. "<br>";
  }
} else {
  echo "No data found";
}
$conn->close();
?>

📁 Save this file also in the same folder.

🌐 7. Testing the PHP + Database Setup

Open browser →
Type:
👉 http://localhost/write_data.php?temperature=30&humidity=65
You should see a success message.
Then open →
👉 http://localhost/read_data.php
You’ll see your inserted records listed neatly.

If both scripts work fine, your backend is ready! 🎉

💡 8. Understanding the System Flow

Step	Function
1️⃣	ESP32 reads sensor data
2️⃣	Sends data via HTTP GET to `write_data.php`
3️⃣	PHP stores data into MySQL
4️⃣	ESP32 or browser fetches it via `read_data.php`
5️⃣	Data is displayed on dashboard or serial monitor

🔒 9. Security Note

Never expose your PHP scripts or MySQL credentials directly online without protection.
Use:

Password protection on server
API keys for ESP32 communication
HTTPS if hosting online

💻 ESP32 + PHP + MySQL Integration – Data Upload and Retrieval Setup

🧠 1. Introduction

Now that we’ve successfully created our MySQL database and PHP scripts, it’s time to make the ESP32 communicate with the backend.
In this part, you’ll learn how to use the HTTPClient library in Arduino to perform both write and read operations on the database through the PHP scripts we made earlier.

Our goal is simple:
📡 ESP32 reads sensor data → sends it to the web server → PHP inserts it into MySQL → you can retrieve it anytime.

⚙️ 2. Libraries Required

Before writing the code, make sure you have the following libraries installed in the Arduino IDE:

WiFi.h – to connect the ESP32 to your WiFi network.
HTTPClient.h – to send and receive data via HTTP requests.
DHT.h – to read temperature and humidity values from the DHT sensor.

If you don’t have them, install them from:
👉 Sketch → Include Library → Manage Libraries… and search for DHT sensor library and Adafruit Unified Sensor.

🔧 3. ESP32 Arduino Code

Here’s the complete and well-commented code for connecting ESP32 to the database through PHP.

/***************************************************
  Project: ESP32 with MySQL Database (Read/Write Operations)
  Author: YaranaIoT Guru
  Description: Sends DHT11 sensor data to MySQL via PHP
****************************************************/

#include <WiFi.h>
#include <HTTPClient.h>
#include "DHT.h"

#define DHTPIN 4          // DHT sensor connected to GPIO4
#define DHTTYPE DHT11     // DHT11 or DHT22

DHT dht(DHTPIN, DHTTYPE);

const char* ssid = "YOUR_WIFI_SSID";       // Change this
const char* password = "YOUR_WIFI_PASSWORD"; // Change this

// Your Local or Online PHP Script URL
String serverName = "http://192.168.1.100/write_data.php"; // Use your server IP

unsigned long lastTime = 0;
unsigned long timerDelay = 5000; // Send data every 5 seconds

void setup() {
  Serial.begin(115200);
  dht.begin();

  WiFi.begin(ssid, password);
  Serial.print("Connecting to WiFi");
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println("\nConnected to WiFi network!");
  Serial.print("IP Address: ");
  Serial.println(WiFi.localIP());
}

void loop() {
  if ((millis() - lastTime) > timerDelay) {
    if (WiFi.status() == WL_CONNECTED) {
      float temperature = dht.readTemperature();
      float humidity = dht.readHumidity();

      if (isnan(temperature) || isnan(humidity)) {
        Serial.println("Failed to read from DHT sensor!");
        return;
      }

      String serverPath = serverName + "?temperature=" + String(temperature) + "&humidity=" + String(humidity);
      Serial.println("Sending data to server: " + serverPath);

      HTTPClient http;
      http.begin(serverPath.c_str());
      int httpResponseCode = http.GET();

      if (httpResponseCode > 0) {
        Serial.print("HTTP Response code: ");
        Serial.println(httpResponseCode);
        String payload = http.getString();
        Serial.println("Server Response: " + payload);
      } else {
        Serial.print("Error code: ");
        Serial.println(httpResponseCode);
      }

      http.end();
    } else {
      Serial.println("WiFi Disconnected. Reconnecting...");
      WiFi.begin(ssid, password);
    }
    lastTime = millis();
  }
}

🧩 4. How the Code Works

WiFi Setup:
The ESP32 connects to your router using the credentials provided. Once connected, it gets a local IP address.
Sensor Data Collection:
The DHT sensor continuously measures temperature and humidity.
HTTP Request Formation:
Every 5 seconds, ESP32 constructs a URL like this:
http://192.168.1.100/write_data.php?temperature=28.5&humidity=65.4
Data Transmission:
ESP32 sends a GET request using the HTTPClient library.
PHP Script Execution:
The PHP file receives the data and inserts it into MySQL.
Response Display:
The ESP32 serial monitor shows a confirmation message:
✅ “Data Inserted Successfully”

🌐 5. Reading Data Back from MySQL

To fetch stored data from the database, create another endpoint:

String readServerName = "http://192.168.1.100/read_data.php";

void readDataFromDatabase() {
  if (WiFi.status() == WL_CONNECTED) {
    HTTPClient http;
    http.begin(readServerName.c_str());
    int httpResponseCode = http.GET();

    if (httpResponseCode > 0) {
      String payload = http.getString();
      Serial.println("Received Data from Database:");
      Serial.println(payload);
    } else {
      Serial.print("Error code: ");
      Serial.println(httpResponseCode);
    }
    http.end();
  } else {
    Serial.println("WiFi Disconnected");
  }
}

You can call this function periodically (e.g., every 10 seconds) or on a button press to read data from MySQL.

💡 6. Testing Your System

✅ Step 1: Upload the code to ESP32
✅ Step 2: Open Serial Monitor (115200 baud)
✅ Step 3: Watch as the ESP32 connects to WiFi and starts sending data
✅ Step 4: Open browser →
👉 http://localhost/read_data.php
and you’ll see the live data updates coming from the ESP32.

📈 7. Output Example

Serial Monitor Output:

Connecting to WiFi....
Connected to WiFi network!
IP Address: 192.168.1.110
Sending data to server: http://192.168.1.100/write_data.php?temperature=27.8&humidity=61.2
HTTP Response code: 200
Server Response: Data Inserted Successfully

Database Output:

ID	Temperature	Humidity	Reading Time
1	27.8	61.2	2025-11-09 14:25:31
2	28.1	60.7	2025-11-09 14:25:36

⚠️ 8. Troubleshooting Tips

Issue	Possible Cause	Solution
“WiFi Disconnected”	Wrong SSID/Password	Double-check credentials
“Connection failed” in PHP	Wrong server IP	Use your local IP from XAMPP
Data not showing in DB	Incorrect URL parameters	Ensure PHP script names match
HTTP Response 404	PHP file not found	Place files in `htdocs` folder
DHT Read Failure	Loose wire or sensor issue

🧩 2. Project Architecture

Here’s the complete flow once again, now with dashboard integration:

[ESP32 + DHT Sensor] → [PHP Script] → [MySQL Database] → [Web Dashboard (Chart.js)]

You’ll be using:

PHP to bridge data between ESP32 and MySQL
MySQL for storage
Chart.js for real-time graph visualization
JavaScript (AJAX) for auto-updating data

🌍 3. Hosting Online Database (Cloud Setup)

You can either continue using localhost (XAMPP) or move to an online host for global access.

🧱 Option 1: Local Server (Development Phase)

If you’re just testing, use your local XAMPP/WAMP setup.

☁️ Option 2: Free Cloud Hosting

For real IoT use, host your files on a free PHP/MySQL service like:

000webhost (https://www.000webhost.com)
InfinityFree (https://www.infinityfree.net)
Hostinger (trial)

Once you sign up:

Upload your write_data.php, read_data.php, and new dashboard files.
Create the same database and table as before in phpMyAdmin.
Copy your live URLs (like https://yourname.000webhostapp.com/write_data.php)
and replace them in the ESP32 code.

💻 4. Creating the Live Dashboard

Now, let’s create an HTML + JavaScript-based dashboard to visualize the data.

Save this file as dashboard.html in your htdocs folder (or upload it to your web host).

<!DOCTYPE html>
<html>
<head>
  <title>ESP32 IoT Dashboard - YaranaIoT Guru</title>
  <script src="https://cdn.jsdelivr.net/npm/chart.js"></script>
  <style>
    body {
      background-color: #0d1117;
      color: #e6edf3;
      font-family: 'Poppins', sans-serif;
      text-align: center;
      margin: 0;
      padding: 0;
    }
    h1 {
      margin-top: 20px;
      font-size: 28px;
    }
    canvas {
      background-color: #161b22;
      border-radius: 10px;
      margin-top: 40px;
    }
  </style>
</head>
<body>
  <h1>🌡️ ESP32 IoT Dashboard (MySQL Data)</h1>
  <canvas id="dataChart" width="800" height="400"></canvas>

  <script>
    const ctx = document.getElementById('dataChart').getContext('2d');
    const dataChart = new Chart(ctx, {
      type: 'line',
      data: {
        labels: [],
        datasets: [
          {
            label: 'Temperature (°C)',
            data: [],
            borderColor: 'rgba(255,99,132,1)',
            fill: false,
            tension: 0.3
          },
          {
            label: 'Humidity (%)',
            data: [],
            borderColor: 'rgba(54,162,235,1)',
            fill: false,
            tension: 0.3
          }
        ]
      },
      options: {
        scales: {
          y: { beginAtZero: true }
        }
      }
    });

    async function fetchData() {
      const response = await fetch('read_data.php');
      const text = await response.text();
      const lines = text.trim().split("<br>");
      const tempData = [];
      const humData = [];
      const labels = [];

      lines.forEach(line => {
        const match = line.match(/Temp:\s([\d.]+).*Humidity:\s([\d.]+).*Time:\s(.+)/);
        if (match) {
          labels.push(match[3]);
          tempData.push(parseFloat(match[1]));
          humData.push(parseFloat(match[2]));
        }
      });

      dataChart.data.labels = labels.reverse();
      dataChart.data.datasets[0].data = tempData.reverse();
      dataChart.data.datasets[1].data = humData.reverse();
      dataChart.update();
    }

    setInterval(fetchData, 5000); // Update every 5 seconds
    fetchData();
  </script>
</body>
</html>

📊 5. How It Works

1️⃣ The dashboard fetches new data every 5 seconds using AJAX (fetch API).
2️⃣ The PHP script (read_data.php) returns the latest database entries.
3️⃣ The Chart.js library dynamically updates the graph in real-time.
4️⃣ You can access this dashboard on your PC, mobile, or tablet — live!

🧠 6. Key Features of This Dashboard

✅ Real-time data refresh every few seconds
✅ Elegant dark UI for modern IoT styling
✅ Separate graphs for temperature & humidity
✅ Fully compatible with both local and online databases
✅ Extendable for other sensors or parameters

🧪 7. Testing the System

1️⃣ Upload dashboard.html and PHP scripts to your server.
2️⃣ Run your ESP32 with the MySQL code from Part 2.
3️⃣ Open the dashboard in your browser →
👉 http://localhost/dashboard.html or your online URL.
4️⃣ You’ll see smooth graph updates with every new data entry.

💡 Tip: Use your phone on the same WiFi to access the dashboard via your local IP address — just type
http://<your_computer_IP>/dashboard.html

🌍 8. Moving to Cloud MySQL (Optional)

If you want your ESP32 to send data from any location, not just your home WiFi:

Use a remote hosting service (like 000webhost or Hostinger).
Update the ESP32 serverName variable with your live PHP URLs.
Make sure your database credentials match your host’s configuration.

Your new ESP32 line will look like this:

String serverName = "https://yourname.000webhostapp.com/write_data.php";

Now your IoT device can work anywhere with an active internet connection 🌐.

🔜 Next in Part 4…

In Part 4, we’ll focus on:

Advanced database optimization
Adding multiple sensors (like LDR, MQ-2, or Ultrasonic)
Exporting logged data to CSV or Excel
Creating a mobile-friendly responsive UI

1) Improve database design (multi-sensor, multi-device)

If you plan to add more sensors/devices, change schema to be flexible and indexable:

CREATE TABLE sensor_data (
  id INT UNSIGNED AUTO_INCREMENT PRIMARY KEY,
  device_id VARCHAR(64) NOT NULL,
  sensor_type VARCHAR(32) NOT NULL,  -- e.g., 'temp','hum','ldr'
  sensor_value FLOAT NOT NULL,
  created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
  INDEX idx_device_time (device_id, created_at),
  INDEX idx_sensor_time (sensor_type, created_at)
);

Benefits:

Store any sensor type with a device id.
Indexed queries by device and time are fast.

2) Use secure, prepared PHP endpoints + token auth

Replace GET-insert with a POST endpoint, prepared statements, and an API token.

write_data_secure.php

<?php
// Simple token-based auth
$API_TOKEN = 'CHANGE_THIS_TO_A_STRONG_TOKEN';

$headers = getallheaders();
if (!isset($headers['X-Api-Token']) || $headers['X-Api-Token'] !== $API_TOKEN) {
  http_response_code(401);
  echo json_encode(['error'=>'Unauthorized']);
  exit;
}

$post = json_decode(file_get_contents('php://input'), true);
$device = $post['device_id'] ?? '';
$type   = $post['sensor_type'] ?? '';
$value  = floatval($post['sensor_value'] ?? 0);

$mysqli = new mysqli("localhost","db_user","db_pass","iot_esp32_db");
if ($mysqli->connect_error) { http_response_code(500); echo json_encode(['error'=>'DB connect']); exit; }

$stmt = $mysqli->prepare("INSERT INTO sensor_data (device_id,sensor_type,sensor_value) VALUES (?,?,?)");
$stmt->bind_param("ssd", $device, $type, $value);
$ok = $stmt->execute();

if ($ok) echo json_encode(['status'=>'ok']);
else { http_response_code(500); echo json_encode(['error'=>$stmt->error]); }

$stmt->close(); $mysqli->close();
?>

Why: prevents SQL injection, allows centralized API token, returns JSON (clean for dashboards).

3) ESP32: POST JSON & retry/backoff

Use HTTPClient POST with header token and exponential backoff:

#include <HTTPClient.h>
String serverUrl = "https://yourserver.com/write_data_secure.php";
const char* apiToken = "CHANGE_THIS_TO_A_STRONG_TOKEN";

bool postData(String device, String type, float value) {
  HTTPClient http;
  http.begin(serverUrl);
  http.addHeader("Content-Type","application/json");
  http.addHeader("X-Api-Token", apiToken);

  String payload = "{\"device_id\":\""+device+"\",\"sensor_type\":\""+type+"\",\"sensor_value\":"+String(value)+"}";
  int code = http.POST(payload);
  String resp = http.getString();
  http.end();
  return (code == 200);
}

// loop: attempt with backoff if fails
int attempt=0;
while (!postData("esp32-01","temp",t) && attempt < 5) {
  delay((1<<attempt) * 1000); // exponential backoff
  attempt++;
}

4) Return JSON for dashboard & pagination

Make read_data.php return JSON and support parameters for pagination/time-window:

<?php
$limit = intval($_GET['limit'] ?? 50);
$device = $_GET['device'] ?? '';
$sensor = $_GET['sensor'] ?? '';

$mysqli = new mysqli(...);
$where = [];
$params = [];

if ($device) { $where[] = "device_id=?"; $params[] = $device; }
if ($sensor) { $where[] = "sensor_type=?"; $params[] = $sensor; }

$sql = "SELECT device_id,sensor_type,sensor_value,created_at FROM sensor_data";
if ($where) $sql .= " WHERE " . implode(" AND ", $where);
$sql .= " ORDER BY created_at DESC LIMIT ?";

$stmt = $mysqli->prepare($sql);
// bind params dynamically (omitted here for brevity)
// execute and build JSON array of rows

Dashboard JS can fetch JSON and plot directly (faster & safer than HTML parsing).

5) CSV export & data download

Provide an export endpoint (export_csv.php) that streams a CSV for a given device/time range:

header('Content-Type: text/csv');
header('Content-Disposition: attachment; filename="export.csv"');
$out = fopen('php://output', 'w');
fputcsv($out, ['id','device_id','sensor_type','sensor_value','created_at']);
while($row = $result->fetch_assoc()) {
  fputcsv($out, $row);
}
fclose($out);

This allows offline analysis in Excel.

6) Database best-practices & retention

Index fields you query (device_id, sensor_type, created_at).
Use partitioning (by date) for very large tables.
Implement a retention policy (e.g., keep raw 1 year) and archive older data to CSV or cheaper storage.

Example retention SQL (delete older than 1 year):

DELETE FROM sensor_data WHERE created_at < NOW() - INTERVAL 1 YEAR;

Run via cron daily.

7) Caching & query optimization

For dashboard, query only recent N rows (e.g., last 200).
Consider a cache layer (Redis) for aggregated queries (daily averages).
Use EXPLAIN in MySQL to inspect slow queries.

8) Move to remote/cloud & TLS

Host on HTTPS-enabled server (Let’s Encrypt).
Use remote managed MySQL (Amazon RDS, Google Cloud SQL) for reliability.
Use API gateway / reverse proxy to rate-limit and add authentication.

9) Monitoring & alerting

Add basic monitoring: check if device last_seen older than X minutes → alert.
Use tools: Grafana + Prometheus (for metrics), or simple cron + email when DB grows too large.

10) Scalability, concurrency & security

Avoid allowing devices to write directly to DB — always go through API layer.
Throttle device writes (e.g., max 1 write per 5s) to protect DB.
Log API calls and monitor for abuse.
Consider per-device API keys and revoke compromised ones.

11) Enhance dashboard UX (responsive & mobile-friendly)

Serve read_data.php?format=json and use Chart.js to plot.
Add controls: time-range picker, device selector, export button.
Use CSS frameworks (Bootstrap/Tailwind) for responsive layout.

Example fetch for JSON:

const res = await fetch('read_data.php?device=esp32-01&limit=100');
const data = await res.json();
// build labels and datasets from data

12) Advanced: Message queue & bulk ingestion

If many devices produce high frequency data, add a lightweight message queue (RabbitMQ / MQTT broker) and a worker process that consumes messages and writes to MySQL in batches — reduces DB connection churn.

13) Final checklist before deploying

Use HTTPS for all endpoints
Use prepared statements and tokens for auth
Implement retries & backoff on devices
Index queries and set retention policy
Provide JSON endpoints for dashboards
Enable server monitoring and backups (daily DB dump)
Test with simulated load (multiple devices)

📞 Contact YaranaIoT Guru Empowering IoT Innovation | ESP32 | Home Automation | Smart Solutions | 50K+ Community

We’d love to hear from you! Whether it’s IoT project queries, collaborations, tech support, custom PCB design, bulk orders, corporate training, college workshops, or freelance development — we’re just one message away.

✉️ Email (Official)

For detailed inquiries, project support, business collaboration, sponsorships, or documentation: 📩 contact@yaranaiotguru.in 📧 Alternate: support@yaranaiotguru.in ⏳ Response: Within 24 hours (Mon–Sat) 💡 Best for attachments (code, schematics, logs, etc.)

📱 Phone / WhatsApp (24×7 Support)

Instant live help, troubleshooting, project consultation, or order updates: 📞 +91 70527 22734 💬 WhatsApp: Chat Now ⏰ Call Hours: Mon–Sat, 10 AM – 7 PM IST 🚀 Emergency? WhatsApp anytime — reply within 1 hour

🌐 Official Website

Tutorials, code, PDFs, schematics, blogs, free tools & online store: 🔗 www.yaranaiotguru.in 🛒 Shop: yaranaiotguru.in/shop (ESP32 DevKits, Sensors, Relays, Custom PCBs, Project Kits)

▶️ YouTube Channel

Step-by-step IoT builds, live coding, ESP32, Blynk, Node-RED, MQTT, Home Assistant & more: 🔗 Yarana IoT Guru 📺 1,200+ Videos | 52K+ Subs | 5.5M+ Views | 4.8★ Rating 🎥 New Video Every Week — 🔔 Subscribe & Turn On Notifications

🛠 GitHub (100% Open Source)

All codes, Arduino sketches, PlatformIO projects, Node-RED flows, MQTT configs & docs: 🔗 github.com/YaranaIotGuru ⭐ 50+ Repos | 10K+ Stars & Forks

🔥 Top Projects:

ESP32 WebSocket Real-Time Dashboard
Smart Home with Blynk & Alexa
IoT Irrigation System with Soil Moisture
MQTT + Node-RED + MySQL Logging
OLED Weather Station with API

📸 Instagram

Daily reels, quick tips, live builds, student showcases & giveaways: 🔗 @YaranaIoTGuru 📱 10K+ Followers | Reels | Stories | Live Sessions

💼 LinkedIn (Professional Network)

B2B, IoT consulting, training, hiring & partnerships: 🔗 Yarana IoT Guru

🤝 Services Offered:

Custom IoT Product Development
Embedded Systems Training
College Workshops & FDPs
PCB Design & Prototyping

🐦 Twitter / X

Real-time updates, polls, project launches & community Q&A: 🔗 @YaranaIoTGuru 📢 Follow for instant alerts

🛠 Hackster.io (Project Showcases)

In-depth write-ups, circuits, BOM, code & ratings: 🔗 hackster.io/yaranaiotguru 🏆 50+ Projects | 100K+ Views | Top 5% Creator

📝 Instructables (DIY Guides)

Beginner-friendly step-by-step guides with templates & troubleshooting: 🔗 instructables.com/member/YaranaIoTGuru

🛠 Featured Guides:

Automatic Plant Watering System
Voice-Controlled Home Appliances
WiFi-enabled Temperature Monitor

📚 Medium Blog

Deep-dive articles, trends, tutorials & career tips in embedded systems: 🔗 medium.com/@yaranaiotguru ✍️ 50+ Articles | 15K+ Readers

🛒 Online Store & Kits

Ready-to-use IoT kits, custom PCBs, sensors & merch: 🔗 yaranaiotguru.in/shop 📦 Free Shipping in India above ₹999 💳 Payment: UPI, Card, Wallet, COD

🌟 Community Platforms

Platform	Link	Purpose
Telegram Channel	t.me/YaranaIoTGuru	Project files, PDFs, updates
Telegram Group	t.me/YaranaIoTCommunity	Peer support, doubts
Discord Server	discord.gg/yarana-iot	Live voice help, coding rooms
WhatsApp Community	Join Here	Announcements & polls

🏢 Office & Studio Address

Yarana Studio & Software (Yarana IoT Guru HQ) 📍 Near Rookh Baba Mandir, Umariya Badal Urf Gainda, Allahabad (Prayagraj), Uttar Pradesh – 212507, India ⭐ Google Rating: 5.0 ★ (100+ Reviews)

🕒 Opening Hours: Mon–Sat: 10:00 AM – 5:00 PM Sunday: Closed

🌐 Associated Website: yaranawebtech.in 🗺️ View on Google Maps: Search “Yarana Studio & Software” 📌 Walk-ins welcome | Appointment recommended for project discussions

Post Views: 337