diff --git a/backend/api/v1/__init__.py b/backend/api/v1/__init__.py
index 550ee0e9..ae7db987 100644
--- a/backend/api/v1/__init__.py
+++ b/backend/api/v1/__init__.py
@@ -51,6 +51,7 @@
 from .carbon import carbon_bp
 from .logistics import smart_freight_bp
 from .carbon_v2 import carbon_v2_bp
+from .iot_sensors import iot_bp
 from .government_scheme import gov_scheme_bp
 from .soil_analytics import soil_analytics_bp
 from .crop_advisory import advisory_bp
@@ -112,6 +113,7 @@
 api_v1.register_blueprint(spatial_yield_bp, url_prefix="/spatial-yield")
 api_v1.register_blueprint(carbon_bp, url_prefix="/carbon")
 api_v1.register_blueprint(carbon_v2_bp, url_prefix="/carbon-v2")
+api_v1.register_blueprint(iot_bp, url_prefix="/iot")
 api_v1.register_blueprint(gov_scheme_bp, url_prefix="/government-schemes")
 api_v1.register_blueprint(soil_analytics_bp, url_prefix="/soil-analytics")
 api_v1.register_blueprint(gov_schemes_bp, url_prefix="/government-schemes")
diff --git a/backend/api/v1/iot_sensors.py b/backend/api/v1/iot_sensors.py
new file mode 100644
index 00000000..6b62c68d
--- /dev/null
+++ b/backend/api/v1/iot_sensors.py
@@ -0,0 +1,149 @@
+from flask import Blueprint, request, jsonify
+from backend.services.iot_sensor_service import IoTSensorService
+from auth_utils import token_required
+
+iot_bp = Blueprint("iot", __name__)
+
+
+@iot_bp.route("/sensors", methods=["GET"])
+@token_required
+def get_sensors(current_user):
+    sensors = IoTSensorService.get_user_sensors(current_user.id)
+    return jsonify({"status": "success", "data": [s.to_dict() for s in sensors]})
+
+
+@iot_bp.route("/sensors", methods=["POST"])
+@token_required
+def register_sensor(current_user):
+    data = request.get_json()
+    if (
+        not data
+        or "sensor_id" not in data
+        or "farm_id" not in data
+        or "sensor_type" not in data
+        or "location" not in data
+    ):
+        return jsonify({"status": "error", "message": "Missing required fields"}), 400
+
+    sensor = IoTSensorService.register_sensor(
+        user_id=current_user.id,
+        farm_id=data["farm_id"],
+        sensor_id=data["sensor_id"],
+        sensor_type=data["sensor_type"],
+        location=data["location"],
+    )
+
+    return jsonify(
+        {
+            "status": "success",
+            "message": "Sensor registered successfully",
+            "data": sensor.to_dict(),
+        }
+    ), 201
+
+
+@iot_bp.route("/sensors/<int:sensor_id>", methods=["GET"])
+@token_required
+def get_sensor(current_user, sensor_id):
+    sensor = IoTSensorService.get_sensor_by_id(sensor_id)
+    if not sensor:
+        return jsonify({"status": "error", "message": "Sensor not found"}), 404
+
+    if sensor.user_id != current_user.id:
+        return jsonify({"status": "error", "message": "Access denied"}), 403
+
+    return jsonify({"status": "success", "data": sensor.to_dict()})
+
+
+@iot_bp.route("/sensors/<int:sensor_id>", methods=["DELETE"])
+@token_required
+def delete_sensor(current_user, sensor_id):
+    sensor = IoTSensorService.get_sensor_by_id(sensor_id)
+    if not sensor:
+        return jsonify({"status": "error", "message": "Sensor not found"}), 404
+
+    if sensor.user_id != current_user.id:
+        return jsonify({"status": "error", "message": "Access denied"}), 403
+
+    IoTSensorService.delete_sensor(sensor_id)
+
+    return jsonify({"status": "success", "message": "Sensor deleted successfully"})
+
+
+@iot_bp.route("/sensors/<int:sensor_id>/readings", methods=["POST"])
+@token_required
+def receive_reading(current_user, sensor_id):
+    sensor = IoTSensorService.get_sensor_by_id(sensor_id)
+    if not sensor:
+        return jsonify({"status": "error", "message": "Sensor not found"}), 404
+
+    if sensor.user_id != current_user.id:
+        return jsonify({"status": "error", "message": "Access denied"}), 403
+
+    data = request.get_json()
+    if not data:
+        return jsonify({"status": "error", "message": "No reading data provided"}), 400
+
+    reading = IoTSensorService.receive_reading(sensor_id, data)
+
+    return jsonify(
+        {"status": "success", "message": "Reading received", "data": reading.to_dict()}
+    ), 201
+
+
+@iot_bp.route("/sensors/<int:sensor_id>/readings", methods=["GET"])
+@token_required
+def get_readings(current_user, sensor_id):
+    sensor = IoTSensorService.get_sensor_by_id(sensor_id)
+    if not sensor:
+        return jsonify({"status": "error", "message": "Sensor not found"}), 404
+
+    if sensor.user_id != current_user.id:
+        return jsonify({"status": "error", "message": "Access denied"}), 403
+
+    hours = request.args.get("hours", 24, type=int)
+    readings = IoTSensorService.get_sensor_readings(sensor_id, hours)
+
+    return jsonify({"status": "success", "data": [r.to_dict() for r in readings]})
+
+
+@iot_bp.route("/sensors/<int:sensor_id>/history", methods=["GET"])
+@token_required
+def get_history(current_user, sensor_id):
+    sensor = IoTSensorService.get_sensor_by_id(sensor_id)
+    if not sensor:
+        return jsonify({"status": "error", "message": "Sensor not found"}), 404
+
+    if sensor.user_id != current_user.id:
+        return jsonify({"status": "error", "message": "Access denied"}), 403
+
+    days = request.args.get("days", 7, type=int)
+    history = IoTSensorService.get_historical_data(sensor_id, days)
+
+    return jsonify({"status": "success", "data": history})
+
+
+@iot_bp.route("/alerts", methods=["GET"])
+@token_required
+def get_alerts(current_user):
+    alerts = IoTSensorService.get_user_alerts(current_user.id)
+    return jsonify({"status": "success", "data": [a.to_dict() for a in alerts]})
+
+
+@iot_bp.route("/alerts/<int:alert_id>/resolve", methods=["POST"])
+@token_required
+def resolve_alert(current_user, alert_id):
+    alert = IoTSensorService.resolve_alert(alert_id)
+    if not alert:
+        return jsonify({"status": "error", "message": "Alert not found"}), 404
+
+    if alert.user_id != current_user.id:
+        return jsonify({"status": "error", "message": "Access denied"}), 403
+
+    return jsonify(
+        {
+            "status": "success",
+            "message": "Alert resolved successfully",
+            "data": alert.to_dict(),
+        }
+    )
diff --git a/backend/models/__init__.py b/backend/models/__init__.py
index 721bfded..acd24e06 100644
--- a/backend/models/__init__.py
+++ b/backend/models/__init__.py
@@ -128,6 +128,7 @@
     EntryType,
     TransactionType,
 )
+from .iot_sensor import IoTSensor, SensorReading, SensorAlert
 from .government_schemes import GovernmentScheme, SchemeApplication, SchemeReminder
 
 __all__ = [
diff --git a/backend/models/iot_sensor.py b/backend/models/iot_sensor.py
new file mode 100644
index 00000000..e8d80ab5
--- /dev/null
+++ b/backend/models/iot_sensor.py
@@ -0,0 +1,106 @@
+from datetime import datetime
+from backend.extensions import db
+
+
+class IoTSensor(db.Model):
+    __tablename__ = "iot_sensors"
+
+    id = db.Column(db.Integer, primary_key=True)
+    sensor_id = db.Column(db.String(100), unique=True, nullable=False)
+    farm_id = db.Column(db.Integer, db.ForeignKey("farms.id"), nullable=False)
+    user_id = db.Column(db.Integer, db.ForeignKey("users.id"), nullable=False)
+
+    sensor_type = db.Column(db.String(50), nullable=False)
+    location = db.Column(db.String(200), nullable=False)
+
+    is_active = db.Column(db.Boolean, default=True)
+    last_seen = db.Column(db.DateTime)
+    installed_at = db.Column(db.DateTime, default=datetime.utcnow)
+
+    def to_dict(self):
+        return {
+            "id": self.id,
+            "sensor_id": self.sensor_id,
+            "farm_id": self.farm_id,
+            "user_id": self.user_id,
+            "sensor_type": self.sensor_type,
+            "location": self.location,
+            "is_active": self.is_active,
+            "last_seen": self.last_seen.isoformat() if self.last_seen else None,
+            "installed_at": self.installed_at.isoformat(),
+        }
+
+
+class SensorReading(db.Model):
+    __tablename__ = "sensor_readings"
+
+    id = db.Column(db.Integer, primary_key=True)
+    sensor_id = db.Column(db.Integer, db.ForeignKey("iot_sensors.id"), nullable=False)
+
+    soil_moisture = db.Column(db.Float)
+    temperature = db.Column(db.Float)
+    humidity = db.Column(db.Float)
+    ph_level = db.Column(db.Float)
+    nitrogen_level = db.Column(db.Float)
+    phosphorus_level = db.Column(db.Float)
+    potassium_level = db.Column(db.Float)
+    light_intensity = db.Column(db.Float)
+    rainfall = db.Column(db.Float)
+
+    battery_level = db.Column(db.Float)
+    signal_strength = db.Column(db.Float)
+
+    is_abnormal = db.Column(db.Boolean, default=False)
+    alert_message = db.Column(db.String(500))
+
+    timestamp = db.Column(db.DateTime, default=datetime.utcnow)
+
+    def to_dict(self):
+        return {
+            "id": self.id,
+            "sensor_id": self.sensor_id,
+            "soil_moisture": self.soil_moisture,
+            "temperature": self.temperature,
+            "humidity": self.humidity,
+            "ph_level": self.ph_level,
+            "nitrogen_level": self.nitrogen_level,
+            "phosphorus_level": self.phosphorus_level,
+            "potassium_level": self.potassium_level,
+            "light_intensity": self.light_intensity,
+            "rainfall": self.rainfall,
+            "battery_level": self.battery_level,
+            "signal_strength": self.signal_strength,
+            "is_abnormal": self.is_abnormal,
+            "alert_message": self.alert_message,
+            "timestamp": self.timestamp.isoformat(),
+        }
+
+
+class SensorAlert(db.Model):
+    __tablename__ = "sensor_alerts"
+
+    id = db.Column(db.Integer, primary_key=True)
+    sensor_id = db.Column(db.Integer, db.ForeignKey("iot_sensors.id"), nullable=False)
+    user_id = db.Column(db.Integer, db.ForeignKey("users.id"), nullable=False)
+
+    alert_type = db.Column(db.String(50), nullable=False)
+    severity = db.Column(db.String(20), nullable=False)
+    message = db.Column(db.String(500), nullable=False)
+
+    is_resolved = db.Column(db.Boolean, default=False)
+    resolved_at = db.Column(db.DateTime)
+
+    created_at = db.Column(db.DateTime, default=datetime.utcnow)
+
+    def to_dict(self):
+        return {
+            "id": self.id,
+            "sensor_id": self.sensor_id,
+            "user_id": self.user_id,
+            "alert_type": self.alert_type,
+            "severity": self.severity,
+            "message": self.message,
+            "is_resolved": self.is_resolved,
+            "resolved_at": self.resolved_at.isoformat() if self.resolved_at else None,
+            "created_at": self.created_at.isoformat(),
+        }
diff --git a/backend/services/iot_sensor_service.py b/backend/services/iot_sensor_service.py
new file mode 100644
index 00000000..986aa813
--- /dev/null
+++ b/backend/services/iot_sensor_service.py
@@ -0,0 +1,210 @@
+from datetime import datetime, timedelta
+from backend.extensions import db
+from backend.models import IoTSensor, SensorReading, SensorAlert, User
+from backend.services.alert_registry import AlertRegistry
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+class IoTSensorService:
+    @staticmethod
+    def register_sensor(user_id, farm_id, sensor_id, sensor_type, location):
+        sensor = IoTSensor(
+            sensor_id=sensor_id,
+            farm_id=farm_id,
+            user_id=user_id,
+            sensor_type=sensor_type,
+            location=location,
+        )
+        db.session.add(sensor)
+        db.session.commit()
+        return sensor
+
+    @staticmethod
+    def get_user_sensors(user_id):
+        return IoTSensor.query.filter_by(user_id=user_id, is_active=True).all()
+
+    @staticmethod
+    def get_sensor_by_id(sensor_id):
+        return IoTSensor.query.filter_by(id=sensor_id).first()
+
+    @staticmethod
+    def update_sensor_status(sensor_id, is_active):
+        sensor = IoTSensor.query.filter_by(id=sensor_id).first()
+        if sensor:
+            sensor.is_active = is_active
+            sensor.last_seen = datetime.utcnow()
+            db.session.commit()
+        return sensor
+
+    @staticmethod
+    def receive_reading(sensor_id, reading_data):
+        sensor = IoTSensor.query.filter_by(id=sensor_id).first()
+        if not sensor:
+            return None
+
+        reading = SensorReading(
+            sensor_id=sensor_id,
+            soil_moisture=reading_data.get("soil_moisture"),
+            temperature=reading_data.get("temperature"),
+            humidity=reading_data.get("humidity"),
+            ph_level=reading_data.get("ph_level"),
+            nitrogen_level=reading_data.get("nitrogen_level"),
+            phosphorus_level=reading_data.get("phosphorus_level"),
+            potassium_level=reading_data.get("potassium_level"),
+            light_intensity=reading_data.get("light_intensity"),
+            rainfall=reading_data.get("rainfall"),
+            battery_level=reading_data.get("battery_level"),
+            signal_strength=reading_data.get("signal_strength"),
+        )
+
+        reading, is_abnormal, alert_message = IoTSensorService._check_abnormal_readings(
+            reading
+        )
+
+        sensor.last_seen = datetime.utcnow()
+        db.session.add(reading)
+        db.session.commit()
+
+        if is_abnormal:
+            IoTSensorService._create_alert(sensor, alert_message)
+
+        return reading
+
+    @staticmethod
+    def _check_abnormal_readings(reading):
+        is_abnormal = False
+        alert_message = ""
+
+        if reading.soil_moisture and reading.soil_moisture < 20:
+            is_abnormal = True
+            reading.is_abnormal = True
+            alert_message = "Low soil moisture detected. Consider irrigation."
+        elif reading.soil_moisture and reading.soil_moisture > 80:
+            is_abnormal = True
+            reading.is_abnormal = True
+            alert_message = "High soil moisture detected. Risk of waterlogging."
+
+        if reading.temperature and reading.temperature > 40:
+            is_abnormal = True
+            reading.is_abnormal = True
+            alert_message = (
+                f"Extreme temperature ({reading.temperature}C) detected. Protect crops."
+            )
+        elif reading.temperature and reading.temperature < 5:
+            is_abnormal = True
+            reading.is_abnormal = True
+            alert_message = f"Freezing temperature ({reading.temperature}C) detected. Take protective measures."
+
+        if reading.ph_level and (reading.ph_level < 5.0 or reading.ph_level > 8.0):
+            is_abnormal = True
+            reading.is_abnormal = True
+            alert_message = (
+                f"Abnormal pH level ({reading.ph_level}). Soil treatment needed."
+            )
+
+        if reading.battery_level and reading.battery_level < 20:
+            is_abnormal = True
+            reading.is_abnormal = True
+            alert_message = "Low sensor battery. Replace soon."
+
+        if is_abnormal:
+            reading.alert_message = alert_message
+
+        return reading, is_abnormal, alert_message
+
+    @staticmethod
+    def _create_alert(sensor, message):
+        alert = SensorAlert(
+            sensor_id=sensor.id,
+            user_id=sensor.user_id,
+            alert_type="ENVIRONMENTAL",
+            severity="HIGH",
+            message=message,
+        )
+        db.session.add(alert)
+
+        AlertRegistry.register_alert(
+            user_id=sensor.user_id,
+            title="IoT Sensor Alert",
+            message=message,
+            category="IOT",
+            priority="HIGH",
+            group_key=f"sensor_{sensor.id}",
+        )
+
+        db.session.commit()
+
+    @staticmethod
+    def get_sensor_readings(sensor_id, hours=24):
+        threshold = datetime.utcnow() - timedelta(hours=hours)
+        return (
+            SensorReading.query.filter(
+                SensorReading.sensor_id == sensor_id,
+                SensorReading.timestamp >= threshold,
+            )
+            .order_by(SensorReading.timestamp.desc())
+            .all()
+        )
+
+    @staticmethod
+    def get_user_alerts(user_id):
+        return (
+            SensorAlert.query.filter_by(user_id=user_id, is_resolved=False)
+            .order_by(SensorAlert.created_at.desc())
+            .all()
+        )
+
+    @staticmethod
+    def resolve_alert(alert_id):
+        alert = SensorAlert.query.filter_by(id=alert_id).first()
+        if alert:
+            alert.is_resolved = True
+            alert.resolved_at = datetime.utcnow()
+            db.session.commit()
+        return alert
+
+    @staticmethod
+    def get_historical_data(sensor_id, days=7):
+        threshold = datetime.utcnow() - timedelta(days=days)
+        readings = (
+            SensorReading.query.filter(
+                SensorReading.sensor_id == sensor_id,
+                SensorReading.timestamp >= threshold,
+            )
+            .order_by(SensorReading.timestamp.asc())
+            .all()
+        )
+
+        return {
+            "readings": [r.to_dict() for r in readings],
+            "stats": IoTSensorService._calculate_stats(readings),
+        }
+
+    @staticmethod
+    def _calculate_stats(readings):
+        if not readings:
+            return {}
+
+        stats = {}
+        metrics = ["soil_moisture", "temperature", "humidity", "ph_level"]
+
+        for metric in metrics:
+            values = [
+                getattr(r, metric) for r in readings if getattr(r, metric) is not None
+            ]
+            if values:
+                stats[f"{metric}_avg"] = sum(values) / len(values)
+                stats[f"{metric}_min"] = min(values)
+                stats[f"{metric}_max"] = max(values)
+
+        return stats
+
+    @staticmethod
+    def delete_sensor(sensor_id):
+        sensor = IoTSensor.query.filter_by(id=sensor_id).first()
+        if sensor:
+            sensor.is_active = False
+            db.session.commit()
+        return sensor
diff --git a/iot_dashboard.html b/iot_dashboard.html
new file mode 100644
index 00000000..59d99c69
--- /dev/null
+++ b/iot_dashboard.html
@@ -0,0 +1,365 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>IoT Sensor Dashboard | AgriTech</title>
+    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.4.0/css/all.min.css">
+    <link href="https://fonts.googleapis.com/css2?family=Outfit:wght@300;400;600;700&display=swap" rel="stylesheet">
+    <style>
+        :root {
+            --primary: #0f172a;
+            --accent: #10b981;
+            --bg: #f3f4f6;
+            --card: #ffffff;
+            --shadow: 0 4px 6px -1px rgb(0 0 0 / 0.1);
+            --danger: #ef4444;
+            --warning: #f59e0b;
+            --info: #3b82f6;
+        }
+
+        body {
+            font-family: 'Outfit', sans-serif;
+            background: var(--bg);
+            margin: 0;
+        }
+
+        .app-shell {
+            display: grid;
+            grid-template-columns: 280px 1fr;
+            min-height: 100vh;
+        }
+
+        .sidebar {
+            background: var(--primary);
+            color: white;
+            padding: 2rem;
+        }
+
+        .nav-link {
+            padding: 0.75rem 1rem;
+            border-radius: 8px;
+            margin-bottom: 0.5rem;
+            display: flex;
+            align-items: center;
+            gap: 0.75rem;
+            cursor: pointer;
+            transition: 0.3s;
+        }
+
+        .nav-link:hover {
+            background: rgba(255, 255, 255, 0.1);
+        }
+
+        .main-content {
+            padding: 3rem;
+        }
+
+        .header {
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+            margin-bottom: 2rem;
+        }
+
+        .stats-grid {
+            display: grid;
+            grid-template-columns: repeat(4, 1fr);
+            gap: 1.5rem;
+            margin-bottom: 2rem;
+        }
+
+        .stat-card {
+            background: var(--card);
+            padding: 1.5rem;
+            border-radius: 16px;
+            box-shadow: var(--shadow);
+        }
+
+        .stat-card h3 {
+            color: #64748b;
+            font-size: 0.85rem;
+            text-transform: uppercase;
+            margin-bottom: 0.5rem;
+        }
+
+        .stat-card .value {
+            font-size: 2rem;
+            font-weight: 700;
+            color: var(--primary);
+        }
+
+        .card {
+            background: var(--card);
+            border-radius: 16px;
+            box-shadow: var(--shadow);
+            padding: 1.5rem;
+            margin-bottom: 1.5rem;
+        }
+
+        .card h2 {
+            margin-top: 0;
+            color: var(--primary);
+        }
+
+        .sensors-grid {
+            display: grid;
+            grid-template-columns: repeat(auto-fill, minmax(300px, 1fr));
+            gap: 1.5rem;
+        }
+
+        .sensor-card {
+            border: 1px solid #e5e7eb;
+            border-radius: 12px;
+            padding: 1.5rem;
+            transition: 0.3s;
+        }
+
+        .sensor-card:hover {
+            transform: translateY(-4px);
+            box-shadow: 0 8px 25px -5px rgb(0 0 0 / 0.1);
+        }
+
+        .sensor-header {
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+            margin-bottom: 1rem;
+        }
+
+        .sensor-status {
+            display: inline-block;
+            padding: 0.25rem 0.75rem;
+            border-radius: 20px;
+            font-size: 0.75rem;
+            font-weight: 600;
+        }
+
+        .status-active {
+            background: #d1fae5;
+            color: #065f46;
+        }
+
+        .status-inactive {
+            background: #fee2e2;
+            color: #991b1b;
+        }
+
+        .reading-grid {
+            display: grid;
+            grid-template-columns: repeat(2, 1fr);
+            gap: 0.75rem;
+            margin-top: 1rem;
+        }
+
+        .reading-item {
+            background: var(--bg);
+            padding: 0.75rem;
+            border-radius: 8px;
+        }
+
+        .reading-item .label {
+            font-size: 0.75rem;
+            color: #64748b;
+        }
+
+        .reading-item .value {
+            font-size: 1.25rem;
+            font-weight: 600;
+            color: var(--primary);
+        }
+
+        .alert-item {
+            padding: 1rem;
+            border-radius: 8px;
+            margin-bottom: 0.75rem;
+            border-left: 4px solid;
+        }
+
+        .alert-high {
+            background: #fef2f2;
+            border-color: var(--danger);
+        }
+
+        .alert-medium {
+            background: #fffbeb;
+            border-color: var(--warning);
+        }
+
+        .alert-info {
+            background: #eff6ff;
+            border-color: var(--info);
+        }
+
+        .btn {
+            padding: 0.75rem 1.5rem;
+            border-radius: 8px;
+            border: none;
+            cursor: pointer;
+            font-weight: 600;
+            transition: 0.3s;
+        }
+
+        .btn-primary {
+            background: var(--accent);
+            color: white;
+        }
+
+        .btn-primary:hover {
+            background: #059669;
+        }
+
+        .btn-danger {
+            background: var(--danger);
+            color: white;
+        }
+
+        .modal {
+            display: none;
+            position: fixed;
+            top: 0;
+            left: 0;
+            width: 100%;
+            height: 100%;
+            background: rgba(0, 0, 0, 0.5);
+            z-index: 1000;
+            align-items: center;
+            justify-content: center;
+        }
+
+        .modal.active {
+            display: flex;
+        }
+
+        .modal-content {
+            background: var(--card);
+            padding: 2rem;
+            border-radius: 16px;
+            width: 90%;
+            max-width: 500px;
+        }
+
+        .form-group {
+            margin-bottom: 1rem;
+        }
+
+        .form-group label {
+            display: block;
+            margin-bottom: 0.5rem;
+            font-weight: 600;
+        }
+
+        .form-group input,
+        .form-group select {
+            width: 100%;
+            padding: 0.75rem;
+            border: 1px solid #d1d5db;
+            border-radius: 8px;
+            font-family: inherit;
+        }
+
+        .history-chart {
+            height: 300px;
+            margin-top: 1rem;
+        }
+    </style>
+</head>
+<body>
+    <div class="app-shell">
+        <div class="sidebar">
+            <h2 style="margin-bottom: 2rem;"><i class="fas fa-seedling"></i> AgriTech</h2>
+            <nav>
+                <div class="nav-link" onclick="window.location.href='index.html'">
+                    <i class="fas fa-home"></i> Dashboard
+                </div>
+                <div class="nav-link" onclick="window.location.href='iot_dashboard.html'">
+                    <i class="fas fa-microchip"></i> IoT Sensors
+                </div>
+                <div class="nav-link" onclick="window.location.href='weather.html'">
+                    <i class="fas fa-cloud-sun"></i> Weather
+                </div>
+                <div class="nav-link" onclick="window.location.href='soil_portal.html'">
+                    <i class="fas fa-mountain"></i> Soil Health
+                </div>
+                <div class="nav-link" onclick="window.location.href='marketplace.html'">
+                    <i class="fas fa-store"></i> Marketplace
+                </div>
+            </nav>
+        </div>
+
+        <div class="main-content">
+            <div class="header">
+                <h1>IoT Sensor Dashboard</h1>
+                <button class="btn btn-primary" onclick="openAddSensorModal()">
+                    <i class="fas fa-plus"></i> Add Sensor
+                </button>
+            </div>
+
+            <div class="stats-grid">
+                <div class="stat-card">
+                    <h3>Active Sensors</h3>
+                    <div class="value" id="activeSensors">0</div>
+                </div>
+                <div class="stat-card">
+                    <h3>Total Readings</h3>
+                    <div class="value" id="totalReadings">0</div>
+                </div>
+                <div class="stat-card">
+                    <h3>Active Alerts</h3>
+                    <div class="value" id="activeAlerts">0</div>
+                </div>
+                <div class="stat-card">
+                    <h3>Avg Soil Moisture</h3>
+                    <div class="value" id="avgMoisture">0%</div>
+                </div>
+            </div>
+
+            <div class="card">
+                <h2>Active Alerts</h2>
+                <div id="alertsContainer"></div>
+            </div>
+
+            <div class="card">
+                <h2>Your Sensors</h2>
+                <div class="sensors-grid" id="sensorsContainer"></div>
+            </div>
+        </div>
+    </div>
+
+    <div class="modal" id="addSensorModal">
+        <div class="modal-content">
+            <h2>Add New Sensor</h2>
+            <form onsubmit="addSensor(event)">
+                <div class="form-group">
+                    <label>Sensor ID</label>
+                    <input type="text" id="sensorId" required>
+                </div>
+                <div class="form-group">
+                    <label>Farm</label>
+                    <select id="farmId" required></select>
+                </div>
+                <div class="form-group">
+                    <label>Sensor Type</label>
+                    <select id="sensorType" required>
+                        <option value="soil_moisture">Soil Moisture</option>
+                        <option value="weather">Weather Station</option>
+                        <option value="ph_sensor">pH Sensor</option>
+                        <option value="nutrient">Nutrient Sensor</option>
+                        <option value="multi">Multi-Sensor</option>
+                    </select>
+                </div>
+                <div class="form-group">
+                    <label>Location</label>
+                    <input type="text" id="sensorLocation" required>
+                </div>
+                <div style="display: flex; gap: 1rem; margin-top: 1.5rem;">
+                    <button type="submit" class="btn btn-primary">Add Sensor</button>
+                    <button type="button" class="btn" onclick="closeAddSensorModal()">Cancel</button>
+                </div>
+            </form>
+        </div>
+    </div>
+
+    <script src="iot_dashboard.js"></script>
+</body>
+</html>
diff --git a/iot_dashboard.js b/iot_dashboard.js
new file mode 100644
index 00000000..251e3341
--- /dev/null
+++ b/iot_dashboard.js
@@ -0,0 +1,413 @@
+const API_BASE = '/api/v1/iot';
+
+let currentUser = null;
+
+async function init() {
+    await loadUserData();
+    await loadSensors();
+    await loadAlerts();
+    await loadStats();
+    setInterval(loadSensors, 30000);
+}
+
+async function loadUserData() {
+    const token = localStorage.getItem('token');
+    if (token) {
+        try {
+            const response = await fetch('/api/v1/auth/me', {
+                headers: {
+                    'Authorization': `Bearer ${token}`
+                }
+            });
+            if (response.ok) {
+                const data = await response.json();
+                currentUser = data.data;
+                loadFarms();
+            }
+        } catch (error) {
+            console.error('Error loading user:', error);
+        }
+    }
+}
+
+async function loadFarms() {
+    if (!currentUser) return;
+    
+    const farmSelect = document.getElementById('farmId');
+    farmSelect.innerHTML = '<option value="">Select Farm</option>';
+    
+    const token = localStorage.getItem('token');
+    try {
+        const response = await fetch('/api/v1/farms', {
+            headers: {
+                'Authorization': `Bearer ${token}`
+            }
+        });
+        if (response.ok) {
+            const data = await response.json();
+            data.data.forEach(farm => {
+                const option = document.createElement('option');
+                option.value = farm.id;
+                option.textContent = farm.name;
+                farmSelect.appendChild(option);
+            });
+        }
+    } catch (error) {
+        console.error('Error loading farms:', error);
+    }
+}
+
+async function loadSensors() {
+    const token = localStorage.getItem('token');
+    if (!token) return;
+    
+    try {
+        const response = await fetch(`${API_BASE}/sensors`, {
+            headers: {
+                'Authorization': `Bearer ${token}`
+            }
+        });
+        if (response.ok) {
+            const data = await response.json();
+            renderSensors(data.data);
+        }
+    } catch (error) {
+        console.error('Error loading sensors:', error);
+    }
+}
+
+function renderSensors(sensors) {
+    const container = document.getElementById('sensorsContainer');
+    
+    if (sensors.length === 0) {
+        container.innerHTML = '<p style="grid-column: 1/-1; text-align: center; color: #64748b;">No sensors registered yet. Add your first sensor to get started!</p>';
+        return;
+    }
+    
+    container.innerHTML = sensors.map(sensor => `
+        <div class="sensor-card">
+            <div class="sensor-header">
+                <div>
+                    <h4 style="margin: 0;">${sensor.sensor_type.replace('_', ' ').toUpperCase()}</h4>
+                    <small style="color: #64748b;">${sensor.location}</small>
+                </div>
+                <span class="sensor-status ${sensor.is_active ? 'status-active' : 'status-inactive'}">
+                    ${sensor.is_active ? 'Active' : 'Inactive'}
+                </span>
+            </div>
+            <div class="reading-grid" id="readings-${sensor.id}">
+                <div class="reading-item">
+                    <div class="label">Last Update</div>
+                    <div class="value" style="font-size: 1rem;">${sensor.last_seen ? new Date(sensor.last_seen).toLocaleString() : 'Never'}</div>
+                </div>
+                <div class="reading-item">
+                    <div class="label">Status</div>
+                    <div class="value" style="font-size: 1rem;">${sensor.is_active ? 'Online' : 'Offline'}</div>
+                </div>
+            </div>
+            <button class="btn btn-primary" style="margin-top: 1rem; width: 100%;" onclick="viewSensorDetails(${sensor.id})">
+                View Details
+            </button>
+        </div>
+    `).join('');
+    
+    sensors.forEach(sensor => {
+        loadSensorReadings(sensor.id);
+    });
+}
+
+async function loadSensorReadings(sensorId) {
+    const token = localStorage.getItem('token');
+    if (!token) return;
+    
+    try {
+        const response = await fetch(`${API_BASE}/sensors/${sensorId}/readings?hours=24`, {
+            headers: {
+                'Authorization': `Bearer ${token}`
+            }
+        });
+        if (response.ok) {
+            const data = await response.json();
+            if (data.data && data.data.length > 0) {
+                const latestReading = data.data[0];
+                updateSensorCard(sensorId, latestReading);
+            }
+        }
+    } catch (error) {
+        console.error('Error loading readings:', error);
+    }
+}
+
+function updateSensorCard(sensorId, reading) {
+    const container = document.getElementById(`readings-${sensorId}`);
+    if (!container || !reading) return;
+    
+    let readingsHtml = '';
+    
+    if (reading.soil_moisture !== null) {
+        readingsHtml += `
+            <div class="reading-item">
+                <div class="label">Soil Moisture</div>
+                <div class="value">${reading.soil_moisture.toFixed(1)}%</div>
+            </div>
+        `;
+    }
+    
+    if (reading.temperature !== null) {
+        readingsHtml += `
+            <div class="reading-item">
+                <div class="label">Temperature</div>
+                <div class="value">${reading.temperature.toFixed(1)}C</div>
+            </div>
+        `;
+    }
+    
+    if (reading.humidity !== null) {
+        readingsHtml += `
+            <div class="reading-item">
+                <div class="label">Humidity</div>
+                <div class="value">${reading.humidity.toFixed(1)}%</div>
+            </div>
+        `;
+    }
+    
+    if (reading.ph_level !== null) {
+        readingsHtml += `
+            <div class="reading-item">
+                <div class="label">pH Level</div>
+                <div class="value">${reading.ph_level.toFixed(1)}</div>
+            </div>
+        `;
+    }
+    
+    if (reading.battery_level !== null) {
+        readingsHtml += `
+            <div class="reading-item">
+                <div class="label">Battery</div>
+                <div class="value">${reading.battery_level.toFixed(0)}%</div>
+            </div>
+        `;
+    }
+    
+    if (reading.signal_strength !== null) {
+        readingsHtml += `
+            <div class="reading-item">
+                <div class="label">Signal</div>
+                <div class="value">${reading.signal_strength.toFixed(0)}%</div>
+            </div>
+        `;
+    }
+    
+    container.innerHTML = readingsHtml || '<div style="grid-column: 1/-1; text-align: center; color: #64748b;">No readings available</div>';
+}
+
+async function loadAlerts() {
+    const token = localStorage.getItem('token');
+    if (!token) return;
+    
+    try {
+        const response = await fetch(`${API_BASE}/alerts`, {
+            headers: {
+                'Authorization': `Bearer ${token}`
+            }
+        });
+        if (response.ok) {
+            const data = await response.json();
+            renderAlerts(data.data);
+        }
+    } catch (error) {
+        console.error('Error loading alerts:', error);
+    }
+}
+
+function renderAlerts(alerts) {
+    const container = document.getElementById('alertsContainer');
+    
+    if (alerts.length === 0) {
+        container.innerHTML = '<p style="text-align: center; color: #64748b;">No active alerts. Great job!</p>';
+        return;
+    }
+    
+    container.innerHTML = alerts.map(alert => `
+        <div class="alert-item alert-${alert.severity.toLowerCase()}">
+            <div style="display: flex; justify-content: space-between; align-items: center;">
+                <div>
+                    <strong>${alert.alert_type.replace('_', ' ').toUpperCase()}</strong>
+                    <p style="margin: 0.25rem 0 0 0;">${alert.message}</p>
+                    <small style="color: #64748b;">${new Date(alert.created_at).toLocaleString()}</small>
+                </div>
+                <button class="btn btn-primary" style="padding: 0.5rem 1rem; font-size: 0.875rem;" onclick="resolveAlert(${alert.id})">
+                    Resolve
+                </button>
+            </div>
+        </div>
+    `).join('');
+}
+
+async function resolveAlert(alertId) {
+    const token = localStorage.getItem('token');
+    if (!token) return;
+    
+    try {
+        const response = await fetch(`${API_BASE}/alerts/${alertId}/resolve`, {
+            method: 'POST',
+            headers: {
+                'Authorization': `Bearer ${token}`
+            }
+        });
+        if (response.ok) {
+            await loadAlerts();
+        }
+    } catch (error) {
+        console.error('Error resolving alert:', error);
+    }
+}
+
+async function loadStats() {
+    const token = localStorage.getItem('token');
+    if (!token) return;
+    
+    try {
+        const sensorsResponse = await fetch(`${API_BASE}/sensors`, {
+            headers: {
+                'Authorization': `Bearer ${token}`
+            }
+        });
+        if (sensorsResponse.ok) {
+            const sensorsData = await sensorsResponse.json();
+            const activeSensors = sensorsData.data.filter(s => s.is_active);
+            document.getElementById('activeSensors').textContent = activeSensors.length;
+            
+            let totalReadings = 0;
+            let totalMoisture = 0;
+            let moistureCount = 0;
+            
+            for (const sensor of activeSensors) {
+                const readingsResponse = await fetch(`${API_BASE}/sensors/${sensor.id}/readings?hours=24`, {
+                    headers: {
+                        'Authorization': `Bearer ${token}`
+                    }
+                });
+                if (readingsResponse.ok) {
+                    const readingsData = await readingsResponse.json();
+                    totalReadings += readingsData.data.length;
+                    
+                    readingsData.data.forEach(reading => {
+                        if (reading.soil_moisture !== null) {
+                            totalMoisture += reading.soil_moisture;
+                            moistureCount++;
+                        }
+                    });
+                }
+            }
+            
+            document.getElementById('totalReadings').textContent = totalReadings;
+            
+            if (moistureCount > 0) {
+                document.getElementById('avgMoisture').textContent = `${(totalMoisture / moistureCount).toFixed(1)}%`;
+            }
+        }
+        
+        const alertsResponse = await fetch(`${API_BASE}/alerts`, {
+            headers: {
+                'Authorization': `Bearer ${token}`
+            }
+        });
+        if (alertsResponse.ok) {
+            const alertsData = await alertsResponse.json();
+            document.getElementById('activeAlerts').textContent = alertsData.data.length;
+        }
+    } catch (error) {
+        console.error('Error loading stats:', error);
+    }
+}
+
+function openAddSensorModal() {
+    document.getElementById('addSensorModal').classList.add('active');
+}
+
+function closeAddSensorModal() {
+    document.getElementById('addSensorModal').classList.remove('active');
+    document.getElementById('sensorId').value = '';
+    document.getElementById('farmId').value = '';
+    document.getElementById('sensorLocation').value = '';
+}
+
+async function addSensor(event) {
+    event.preventDefault();
+    
+    const token = localStorage.getItem('token');
+    if (!token) {
+        alert('Please login first');
+        return;
+    }
+    
+    const sensorData = {
+        sensor_id: document.getElementById('sensorId').value,
+        farm_id: parseInt(document.getElementById('farmId').value),
+        sensor_type: document.getElementById('sensorType').value,
+        location: document.getElementById('sensorLocation').value
+    };
+    
+    try {
+        const response = await fetch(`${API_BASE}/sensors`, {
+            method: 'POST',
+            headers: {
+                'Authorization': `Bearer ${token}`,
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify(sensorData)
+        });
+        
+        if (response.ok) {
+            closeAddSensorModal();
+            loadSensors();
+            loadStats();
+            alert('Sensor added successfully!');
+        } else {
+            const errorData = await response.json();
+            alert(`Error: ${errorData.message}`);
+        }
+    } catch (error) {
+        console.error('Error adding sensor:', error);
+        alert('Error adding sensor. Please try again.');
+    }
+}
+
+async function viewSensorDetails(sensorId) {
+    const token = localStorage.getItem('token');
+    if (!token) return;
+    
+    try {
+        const historyResponse = await fetch(`${API_BASE}/sensors/${sensorId}/history?days=7`, {
+            headers: {
+                'Authorization': `Bearer ${token}`
+            }
+        });
+        
+        if (historyResponse.ok) {
+            const historyData = await historyResponse.json();
+            const history = historyData.data;
+            
+            const stats = history.stats || {};
+            let statsHtml = 'Historical Data (Last 7 Days):\n\n';
+            
+            if (stats.soil_moisture_avg) {
+                statsHtml += `Average Soil Moisture: ${stats.soil_moisture_avg.toFixed(1)}%\n`;
+            }
+            if (stats.temperature_avg) {
+                statsHtml += `Average Temperature: ${stats.temperature_avg.toFixed(1)}C\n`;
+            }
+            if (stats.humidity_avg) {
+                statsHtml += `Average Humidity: ${stats.humidity_avg.toFixed(1)}%\n`;
+            }
+            
+            alert(statsHtml);
+        }
+    } catch (error) {
+        console.error('Error loading sensor details:', error);
+        alert('Error loading sensor details');
+    }
+}
+
+document.addEventListener('DOMContentLoaded', init);