diff --git a/CHANGELOG.md b/CHANGELOG.md
index 3b2af71..49ed263 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -13,6 +13,17 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ### Fixed
 
 
+## [0.3.7]
+
+### Added
+
+- `Date` column type support ([#15](https://github.com/CollierKing/sqlalchemy-cloudflare-d1/issues/15))
+  - Added `D1Date` type processor that converts Python `date` objects to ISO 8601 strings on bind and parses them back on result
+  - Supports nullable date columns, date filtering/comparison, and ORM usage
+  - Works in both REST API and Worker modes
+  - Thanks to [@xelandernt](https://github.com/xelandernt) for the contribution ([PR #16](https://github.com/CollierKing/sqlalchemy-cloudflare-d1/pull/16))
+
+
 ## [0.3.6]
 
 ### Fixed
diff --git a/examples/workers/src/entry.py b/examples/workers/src/entry.py
index 7733fe2..1d967d5 100644
--- a/examples/workers/src/entry.py
+++ b/examples/workers/src/entry.py
@@ -131,6 +131,13 @@ async def fetch(self, request, env):
             return await self.test_datetime_nullable()
         elif path == "datetime-orm":
             return await self.test_datetime_orm()
+        # Date column tests (GitHub issue #15)
+        elif path == "date-basic":
+            return await self.test_date_basic()
+        elif path == "date-nullable":
+            return await self.test_date_nullable()
+        elif path == "date-orm":
+            return await self.test_date_orm()
         else:
             return await self.index()
 
@@ -186,6 +193,9 @@ async def index(self):
                 "/datetime-non-utc": "Test DateTime with non-UTC timezone",
                 "/datetime-nullable": "Test nullable DateTime columns",
                 "/datetime-orm": "Test DateTime via ORM session",
+                "/date-basic": "Test Date column insert/retrieve",
+                "/date-nullable": "Test nullable Date columns",
+                "/date-orm": "Test Date via ORM session",
             },
             "package": "sqlalchemy-cloudflare-d1",
             "connection_type": "WorkerConnection (D1 binding)",
@@ -3175,3 +3185,220 @@ class News(Base):
                 },
                 status=500,
             )
+
+    async def test_date_basic(self):
+        """Test Date column insert and retrieve."""
+        from datetime import date
+        from sqlalchemy import (
+            Column,
+            Date,
+            Integer,
+            MetaData,
+            String,
+            Table,
+            select,
+        )
+
+        table_name = f"test_date_{uuid.uuid4().hex[:8]}"
+
+        try:
+            engine = self.get_engine()
+            metadata = MetaData()
+
+            test_table = Table(
+                table_name,
+                metadata,
+                Column("id", Integer, primary_key=True),
+                Column("title", String(127)),
+                Column("birth_date", Date),
+            )
+
+            metadata.create_all(engine)
+
+            date_value = date(2025, 12, 29)
+
+            with engine.connect() as conn:
+                conn.execute(
+                    test_table.insert().values(title="Test", birth_date=date_value)
+                )
+                conn.commit()
+
+                result = conn.execute(
+                    select(test_table.c.title, test_table.c.birth_date)
+                )
+                row = result.fetchone()
+
+            metadata.drop_all(engine)
+
+            success = (
+                row is not None
+                and row[0] == "Test"
+                and isinstance(row[1], date)
+                and row[1].year == 2025
+                and row[1].month == 12
+                and row[1].day == 29
+            )
+
+            return Response.json(
+                {
+                    "test": "date_basic",
+                    "success": success,
+                    "title": row[0] if row else None,
+                    "birth_date_type": type(row[1]).__name__ if row else None,
+                    "year": row[1].year if row and isinstance(row[1], date) else None,
+                }
+            )
+        except Exception as e:
+            try:
+                metadata.drop_all(engine)
+            except Exception:
+                pass
+            return Response.json(
+                {"test": "date_basic", "success": False, "error": str(e)},
+                status=500,
+            )
+
+    async def test_date_nullable(self):
+        """Test nullable Date columns handle NULL correctly."""
+        from datetime import date
+        from sqlalchemy import (
+            Column,
+            Date,
+            Integer,
+            MetaData,
+            String,
+            Table,
+            select,
+        )
+
+        table_name = f"test_date_null_{uuid.uuid4().hex[:8]}"
+
+        try:
+            engine = self.get_engine()
+            metadata = MetaData()
+
+            test_table = Table(
+                table_name,
+                metadata,
+                Column("id", Integer, primary_key=True),
+                Column("title", String(127)),
+                Column("event_date", Date, nullable=True),
+            )
+
+            metadata.create_all(engine)
+
+            with engine.connect() as conn:
+                conn.execute(
+                    test_table.insert().values(
+                        title="With Date",
+                        event_date=date(2025, 1, 1),
+                    )
+                )
+                conn.execute(
+                    test_table.insert().values(title="No Date", event_date=None)
+                )
+                conn.commit()
+
+                result = conn.execute(
+                    select(test_table.c.title, test_table.c.event_date).order_by(
+                        test_table.c.id
+                    )
+                )
+                rows = result.fetchall()
+
+            metadata.drop_all(engine)
+
+            success = (
+                len(rows) == 2
+                and rows[0][0] == "With Date"
+                and isinstance(rows[0][1], date)
+                and rows[1][0] == "No Date"
+                and rows[1][1] is None
+            )
+
+            return Response.json(
+                {
+                    "test": "date_nullable",
+                    "success": success,
+                    "with_date_is_date": isinstance(rows[0][1], date)
+                    if rows
+                    else False,
+                    "no_date_is_none": rows[1][1] is None if len(rows) > 1 else False,
+                }
+            )
+        except Exception as e:
+            try:
+                metadata.drop_all(engine)
+            except Exception:
+                pass
+            return Response.json(
+                {"test": "date_nullable", "success": False, "error": str(e)},
+                status=500,
+            )
+
+    async def test_date_orm(self):
+        """Test Date via ORM session."""
+        from datetime import date
+        from sqlalchemy import Integer, String, Date
+        from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column, Session
+
+        engine = create_engine_from_binding(self.env.DB)
+        table_name = f"test_date_orm_{uuid.uuid4().hex[:8]}"
+
+        try:
+
+            class Base(DeclarativeBase):
+                pass
+
+            class Event(Base):
+                __tablename__ = table_name
+                id: Mapped[int] = mapped_column(Integer, primary_key=True, index=True)
+                title: Mapped[str] = mapped_column(String(127))
+                event_date: Mapped[date] = mapped_column(Date)
+
+            Base.metadata.create_all(engine)
+
+            test_date = date(2025, 12, 29)
+
+            with Session(engine) as session:
+                event = Event(
+                    title="Date Test Event",
+                    event_date=test_date,
+                )
+                session.add(event)
+                session.commit()
+                session.refresh(event)
+                event_title = event.title
+                event_date_is_date = isinstance(event.event_date, date)
+                event_date_value = event.event_date
+
+            Base.metadata.drop_all(engine)
+
+            success = event_date_is_date and event_date_value == test_date
+
+            return Response.json(
+                {
+                    "test": "date_orm",
+                    "success": success,
+                    "event_title": event_title,
+                    "event_date_is_date": event_date_is_date,
+                }
+            )
+        except Exception as e:
+            try:
+                from sqlalchemy import MetaData, Table
+
+                md = MetaData()
+                Table(table_name, md)
+                md.drop_all(engine)
+            except Exception:
+                pass
+            return Response.json(
+                {
+                    "test": "date_orm",
+                    "success": False,
+                    "error": str(e),
+                    "error_type": type(e).__name__,
+                },
+                status=500,
+            )
diff --git a/examples/workers/uv.lock b/examples/workers/uv.lock
index 4a4b9ef..25825d2 100644
--- a/examples/workers/uv.lock
+++ b/examples/workers/uv.lock
@@ -614,7 +614,7 @@ wheels = [
 
 [[package]]
 name = "sqlalchemy-cloudflare-d1"
-version = "0.3.5"
+version = "0.3.7"
 source = { editable = "../../" }
 dependencies = [
     { name = "httpx" },
@@ -631,7 +631,7 @@ requires-dist = [
     { name = "mypy", marker = "extra == 'dev'", specifier = ">=1.0.0" },
     { name = "pytest", marker = "extra == 'dev'", specifier = ">=7.0.0" },
     { name = "pytest-asyncio", marker = "extra == 'dev'", specifier = ">=0.21.0" },
-    { name = "ruff", marker = "extra == 'dev'", specifier = ">=0.0.280" },
+    { name = "ruff", marker = "extra == 'dev'", specifier = "==0.12.4" },
     { name = "sqlalchemy", specifier = ">=2.0.0" },
     { name = "typing-extensions", specifier = ">=4.0.0" },
 ]
@@ -646,7 +646,7 @@ dev = [
     { name = "pytest-asyncio", specifier = ">=0.21.0" },
     { name = "pytest-socket", specifier = ">=0.7.0" },
     { name = "requests", specifier = ">=2.31.0" },
-    { name = "ruff", specifier = ">=0.0.280" },
+    { name = "ruff", specifier = "==0.12.4" },
 ]
 
 [[package]]
diff --git a/pyproject.toml b/pyproject.toml
index cbf94c4..8a2ddd8 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -1,6 +1,6 @@
 [project]
 name = "sqlalchemy-cloudflare-d1"
-version = "0.3.6"
+version = "0.3.7"
 description = "A SQLAlchemy dialect for Cloudflare's D1 Serverless SQLite Database"
 readme = "README.md"
 authors = [
@@ -83,6 +83,7 @@ addopts = "--ignore=tests/integration"
 [dependency-groups]
 dev = [
     "codespell>=2.4.1",
+    "greenlet>=3.2.3",
     "mypy>=1.17.0",
     "pandas>=2.0.0",
     "pytest>=8.4.1",
diff --git a/src/sqlalchemy_cloudflare_d1/dialect.py b/src/sqlalchemy_cloudflare_d1/dialect.py
index dbd603f..49a5416 100644
--- a/src/sqlalchemy_cloudflare_d1/dialect.py
+++ b/src/sqlalchemy_cloudflare_d1/dialect.py
@@ -3,7 +3,7 @@
 """
 
 import base64
-from datetime import datetime
+from datetime import datetime, date
 from typing import Any, Callable, Dict, List, Optional
 
 from sqlalchemy.engine import default
@@ -16,6 +16,7 @@
     NUMERIC,
     REAL,
     TEXT,
+    Date,
 )
 from sqlalchemy import text
 
@@ -112,6 +113,53 @@ def process(value: Any) -> Optional[bytes]:
         return process
 
 
+# MARK: - Date Type Processor
+
+
+class D1Date(Date):
+    """Custom Date type for Cloudflare D1.
+
+    D1 does not accept Python date objects as bind parameters - they arrive
+    as JS `object` type and raise D1_TYPE_ERROR. This type processor converts
+    date objects to ISO 8601 strings on bind and parses them back on result.
+    """
+
+    def bind_processor(self, dialect: Dialect) -> Callable[[Any], Optional[str]]:
+        """Convert Python date to ISO 8601 string for D1."""
+
+        # MARK: - bind_processor
+        def process(value: Any) -> Optional[str]:
+            if value is None:
+                return None
+            if isinstance(value, date):
+                return value.isoformat()
+            if isinstance(value, str):
+                return value
+            return str(value)
+
+        return process
+
+    def result_processor(
+        self, dialect: Dialect, coltype: Any
+    ) -> Callable[[Any], Optional[date]]:
+        """Convert ISO 8601 string from D1 back to Python date."""
+
+        # MARK: - result_processor
+        def process(value: Any) -> Optional[date]:
+            if value is None:
+                return None
+            if isinstance(value, date):
+                return value
+            if isinstance(value, str):
+                try:
+                    return date.fromisoformat(value)
+                except ValueError:
+                    return value
+            return value
+
+        return process
+
+
 # MARK: - DateTime Type Processor
 
 
@@ -194,6 +242,7 @@ class CloudflareD1Dialect(default.DefaultDialect):
     # Type mapping from SQLAlchemy to D1/SQLite
     colspecs = {
         Boolean: D1Boolean,
+        Date: D1Date,
         DateTime: D1DateTime,
         LargeBinary: D1LargeBinary,
     }
diff --git a/tests/integration/test_restapi_integration.py b/tests/integration/test_restapi_integration.py
index 700b1f9..ada0e05 100644
--- a/tests/integration/test_restapi_integration.py
+++ b/tests/integration/test_restapi_integration.py
@@ -2459,6 +2459,175 @@ class News(Base):
             Base.metadata.drop_all(d1_engine)
 
 
+# MARK - Date Column Tests (Issue #15)
+
+
+class TestDateColumn:
+    """Test Date column handling.
+
+    D1 does not accept Python date objects as bind parameters. The
+    D1Date type processor converts dates to ISO 8601 strings on bind
+    and parses them back on result.
+    """
+
+    def test_date_insert_and_retrieve(self, d1_engine, test_table_name):
+        """Test that Date columns can store and retrieve date values."""
+        from datetime import date
+        from sqlalchemy import Date
+
+        metadata = MetaData()
+        test_table = Table(
+            test_table_name,
+            metadata,
+            Column("id", Integer, primary_key=True),
+            Column("title", String(127)),
+            Column("birth_date", Date),
+        )
+
+        metadata.create_all(d1_engine)
+
+        try:
+            date_value = date(2025, 12, 29)
+
+            with d1_engine.connect() as conn:
+                conn.execute(
+                    test_table.insert().values(title="Test", birth_date=date_value)
+                )
+                conn.commit()
+
+                result = conn.execute(
+                    select(test_table.c.title, test_table.c.birth_date)
+                )
+                row = result.fetchone()
+
+            assert row is not None
+            assert row[0] == "Test"
+            assert isinstance(row[1], date)
+            assert row[1].year == 2025
+            assert row[1].month == 12
+            assert row[1].day == 29
+        finally:
+            metadata.drop_all(d1_engine)
+
+    def test_date_nullable(self, d1_engine, test_table_name):
+        """Test nullable Date columns handle NULL correctly."""
+        from datetime import date
+        from sqlalchemy import Date
+
+        metadata = MetaData()
+        test_table = Table(
+            test_table_name,
+            metadata,
+            Column("id", Integer, primary_key=True),
+            Column("title", String(127)),
+            Column("event_date", Date, nullable=True),
+        )
+
+        metadata.create_all(d1_engine)
+
+        try:
+            with d1_engine.connect() as conn:
+                # Insert row with NULL date
+                conn.execute(
+                    test_table.insert().values(title="No Date", event_date=None)
+                )
+
+                # Insert row with actual date
+                conn.execute(
+                    test_table.insert().values(
+                        title="With Date", event_date=date(2025, 1, 1)
+                    )
+                )
+                conn.commit()
+
+                result = conn.execute(
+                    select(test_table.c.title, test_table.c.event_date)
+                )
+                rows = result.fetchall()
+
+            assert len(rows) == 2
+            assert rows[0][1] is None
+            assert isinstance(rows[1][1], date)
+        finally:
+            metadata.drop_all(d1_engine)
+
+    def test_date_orm_session(self, d1_engine):
+        """Test Date via ORM session."""
+        from datetime import date
+        from sqlalchemy import Date
+        from sqlalchemy.orm import Mapped, Session, declarative_base, mapped_column
+
+        Base = declarative_base()
+
+        class Event(Base):
+            __tablename__ = f"events_{uuid.uuid4().hex[:8]}"
+
+            id: Mapped[int] = mapped_column(Integer, primary_key=True)
+            title: Mapped[str] = mapped_column(String(127))
+            event_date: Mapped[date] = mapped_column(Date)
+
+        Base.metadata.create_all(d1_engine)
+
+        try:
+            test_date = date(2025, 12, 29)
+
+            with Session(d1_engine) as session:
+                event = Event(title="Test Event", event_date=test_date)
+                session.add(event)
+                session.commit()
+
+                # Query back
+                retrieved_event = session.query(Event).first()
+
+                assert retrieved_event is not None
+                assert retrieved_event.title == "Test Event"
+                assert isinstance(retrieved_event.event_date, date)
+                assert retrieved_event.event_date == test_date
+        finally:
+            Base.metadata.drop_all(d1_engine)
+
+    def test_date_filter_query(self, d1_engine, test_table_name):
+        """Test filtering by Date column values."""
+        from datetime import date
+        from sqlalchemy import Date
+
+        metadata = MetaData()
+        test_table = Table(
+            test_table_name,
+            metadata,
+            Column("id", Integer, primary_key=True),
+            Column("title", String(127)),
+            Column("event_date", Date),
+        )
+
+        metadata.create_all(d1_engine)
+
+        try:
+            date_old = date(2024, 1, 1)
+            date_new = date(2025, 6, 15)
+
+            with d1_engine.connect() as conn:
+                conn.execute(
+                    test_table.insert().values(title="Old", event_date=date_old)
+                )
+                conn.execute(
+                    test_table.insert().values(title="New", event_date=date_new)
+                )
+                conn.commit()
+
+                # Filter for entries after 2025-01-01
+                cutoff = date(2025, 1, 1).isoformat()
+                result = conn.execute(
+                    select(test_table.c.title).where(test_table.c.event_date > cutoff)
+                )
+                rows = result.fetchall()
+
+            assert len(rows) == 1
+            assert rows[0][0] == "New"
+        finally:
+            metadata.drop_all(d1_engine)
+
+
 # MARK: - DateTime Column Tests (Issue #13)
 
 
diff --git a/tests/integration/test_worker_integration.py b/tests/integration/test_worker_integration.py
index 2482d45..daf7beb 100644
--- a/tests/integration/test_worker_integration.py
+++ b/tests/integration/test_worker_integration.py
@@ -785,6 +785,56 @@ def test_inserted_primary_key_via_sqlalchemy_core(self, dev_server):
         assert data["lastrowid_2"] == 2
 
 
+# MARK: = Date Column Tests (Issue #15)
+
+
+class TestWorkerDateColumn:
+    """Test Date column handling via Worker endpoints.
+
+    These tests mirror the TestDateColumn tests in test_restapi_integration.py.
+    """
+
+    def test_date_insert_and_retrieve(self, dev_server):
+        """Test Date column insert and retrieve."""
+        port = dev_server
+        response = requests.get(f"http://localhost:{port}/date-basic")
+
+        assert response.status_code == 200, f"date_basic failed: {response.json()}"
+        data = response.json()
+
+        assert data["test"] == "date_basic"
+        assert data["success"] is True, f"date_basic failed: error={data.get('error')}"
+        assert data["birth_date_type"] == "date"
+
+    def test_date_nullable(self, dev_server):
+        """Test nullable Date columns handle NULL correctly."""
+        port = dev_server
+        response = requests.get(f"http://localhost:{port}/date-nullable")
+
+        assert response.status_code == 200, f"date_nullable failed: {response.json()}"
+        data = response.json()
+
+        assert data["test"] == "date_nullable"
+        assert data["success"] is True, (
+            f"date_nullable failed: error={data.get('error')}"
+        )
+        assert data["with_date_is_date"] is True
+        assert data["no_date_is_none"] is True
+
+    def test_date_orm_session(self, dev_server):
+        """Test Date via ORM session."""
+        port = dev_server
+        response = requests.get(f"http://localhost:{port}/date-orm")
+
+        assert response.status_code == 200, f"date_orm failed: {response.json()}"
+        data = response.json()
+
+        assert data["test"] == "date_orm"
+        assert data["success"] is True, f"date_orm failed: error={data.get('error')}"
+        assert data["event_title"] == "Date Test Event"
+        assert data["event_date_is_date"] is True
+
+
 # MARK: - DateTime Column Tests (Issue #13)
 
 
diff --git a/uv.lock b/uv.lock
index 9b6b704..8c5dbc8 100644
--- a/uv.lock
+++ b/uv.lock
@@ -922,7 +922,7 @@ wheels = [
 
 [[package]]
 name = "sqlalchemy-cloudflare-d1"
-version = "0.3.6"
+version = "0.3.7"
 source = { editable = "." }
 dependencies = [
     { name = "httpx" },
@@ -946,6 +946,7 @@ dev = [
 [package.dev-dependencies]
 dev = [
     { name = "codespell" },
+    { name = "greenlet" },
     { name = "mypy" },
     { name = "pandas" },
     { name = "pytest" },
@@ -973,6 +974,7 @@ provides-extras = ["async", "dev"]
 [package.metadata.requires-dev]
 dev = [
     { name = "codespell", specifier = ">=2.4.1" },
+    { name = "greenlet", specifier = ">=3.2.3" },
     { name = "mypy", specifier = ">=1.17.0" },
     { name = "pandas", specifier = ">=2.0.0" },
     { name = "pytest", specifier = ">=8.4.1" },