@@ -7,6 +7,13 @@
 - Added `force` parameter to `schedule_task` to control behavior when updating dynamic task instances
   - Default (`force=False`): Fails with `TaskLockedException` if task is locked, preserves sooner execution time to prevent schedule postponement
   - With `force=True`: Unconditionally overwrites task state including locks and schedule
+- Added new task state query API for inspecting both static and dynamic tasks
+  - `get_task(task, instance_name=None)` - Query the state of any task (static or dynamic)
+    - For static tasks: `get_task(my_task)`
+    - For dynamic tasks: `get_task(template, "instance")` or `get_task(concrete_instance)`
+  - `list_tasks(parent_task, limit=None, continuation_token=None)` - List all instances of a dynamic task with pagination
+  - Returns `TaskState` objects containing task, scheduled_at, locked_until, and locked_by
+  - Implemented across all backends: PostgreSQL, MySQL, SQLite, DynamoDB, Redis
 
 ### Bug Fixes
 
@@ -22,6 +29,12 @@
 
 - Added `TaskLockedException` exception type for clearer error handling when tasks are locked
 - Updated `register_task` across all backends to accept `force` parameter
+- Added new `get_task_state()` method to Repository interface for querying individual task state
+- Added new `list_task_states()` method to Repository interface for paginated listing of dynamic task instances
+- Added new public API methods to `PyncetteContext`:
+  - `get_task(task, instance_name=None)` - Query state of static or dynamic tasks
+  - `list_tasks(parent_task, limit=None, continuation_token=None)` - List dynamic task instances with pagination
+- Added new model classes: `TaskState` (task state snapshot) and `ListTasksResponse` (paginated results)
 
 ## 1.0.0 (2025-10-17)
 
 
@@ -411,6 +411,118 @@ With `force=True`, the task will be updated immediately even if it is executing.
 
 When updating the schedule of an existing task, the sooner of the existing and new execution times is used, preventing repeated calls from indefinitely postponing execution.
 
+## Querying task state
+
+Pyncette provides methods to inspect the state of both static and dynamic tasks.
+
+### Getting a single task
+
+You can retrieve the state of any task (static or dynamic):
+
+**For static tasks:**
+
+```python
+@app.task(interval=datetime.timedelta(minutes=5))
+async def cleanup(context: Context) -> None:
+    print("Running cleanup")
+
+
+async with app.create() as app_context:
+    # Get the static task state
+    task_state = await app_context.get_task(cleanup)
+
+    if task_state:
+        print(f"Task: {task_state.task.name}")
+        print(f"Next execution: {task_state.scheduled_at}")
+        print(f"Locked until: {task_state.locked_until}")
+        print(f"Locked by: {task_state.locked_by}")
+    else:
+        print("Task not found")
+```
+
+**For dynamic tasks:**
+
+```python
+@app.dynamic_task()
+async def hello(context: Context) -> None:
+    print(f"Hello {context.args['username']}")
+
+
+async with app.create() as app_context:
+    await app_context.schedule_task(
+        hello, "user_1", interval=datetime.timedelta(minutes=5), username="Alice"
+    )
+
+    # Get the dynamic task state using template + instance_name
+    task_state = await app_context.get_task(hello, "user_1")
+
+    # Or using a pre-instantiated task
+    concrete_task = hello.instantiate("user_1", interval=datetime.timedelta(minutes=5))
+    task_state = await app_context.get_task(concrete_task)
+
+    if task_state:
+        print(f"Task: {task_state.task.name}")
+        print(f"Next execution: {task_state.scheduled_at}")
+        print(f"Locked until: {task_state.locked_until}")
+        print(f"Locked by: {task_state.locked_by}")
+        print(f"Username: {task_state.task.extra_args['username']}")
+    else:
+        print("Task not found")
+```
+
+The `TaskState` object contains:
+
+- `task`: The task instance with all its parameters
+- `scheduled_at`: When the task is next scheduled to execute
+- `locked_until`: When the current execution lease expires (None if not locked)
+- `locked_by`: UUID of the worker holding the lease (None if not locked)
+
+### Listing all task instances
+
+You can list all instances of a dynamic task with pagination (note: this is only available for dynamic tasks, as static tasks have only a single instance):
+
+```python
+@app.dynamic_task()
+async def hello(context: Context) -> None:
+    print(f"Hello {context.args['username']}")
+
+
+async with app.create() as app_context:
+    # Schedule multiple tasks
+    for i in range(100):
+        await app_context.schedule_task(
+            hello,
+            f"user_{i}",
+            interval=datetime.timedelta(minutes=5),
+            username=f"User{i}",
+        )
+
+    # List all tasks with pagination
+    response = await app_context.list_tasks(hello, limit=10)
+
+    for task_state in response.tasks:
+        print(
+            f"Task: {task_state.task.name}, Username: {task_state.task.extra_args['username']}"
+        )
+
+    # Continue with next page if available
+    while response.continuation_token:
+        response = await app_context.list_tasks(
+            hello, limit=10, continuation_token=response.continuation_token
+        )
+        for task_state in response.tasks:
+            print(
+                f"Task: {task_state.task.name}, Username: {task_state.task.extra_args['username']}"
+            )
+```
+
+Notes:
+
+- Results are not guaranteed to be in any particular order
+- The `limit` parameter is an upper bound; backends may return fewer results
+- Pagination support varies by backend (DynamoDB, Redis, SQL databases all support it)
+- The continuation token is opaque and backend-specific
+
 ## Performance
 
 Tasks are executed in parallel. If you have a lot of long running tasks, you can set `concurrency_limit` in `Pyncette` constructor, as this ensures that there are at most that many executing tasks at any given time. If there are no free slots in the semaphore, this will serve as a back-pressure and ensure that we don't poll additional tasks until some of the currently executing ones finish, enabling the pending tasks to be scheduled on other instances of your app. Setting `concurrency_limit` to 1 is equivalent of serializing the execution of all the tasks.
 
@@ -1,6 +1,6 @@
 site_name: Pyncette
 site_description: A reliable distributed scheduler with pluggable storage backends for Async Python
-site_url: https://pyncette.readthedocs.io
+site_url: https://tibordp.github.io/pyncette/
 repo_url: https://github.com/tibordp/pyncette
 repo_name: tibordp/pyncette
 edit_uri: edit/master/docs/
 
@@ -21,9 +21,11 @@
 from pyncette.model import ContinuationToken
 from pyncette.model import ExecutionMode
 from pyncette.model import Lease
+from pyncette.model import ListTasksResponse
 from pyncette.model import PollResponse
 from pyncette.model import QueryResponse
 from pyncette.model import ResultType
+from pyncette.model import TaskState
 from pyncette.repository import Repository
 from pyncette.task import Task
 
@@ -378,6 +380,97 @@ async def unlock_task(self, utc_now: datetime.datetime, task: Task, lease: Lease
 
         raise PyncetteException("Unable to acquire the lock on the task due to contention")
 
+    async def get_task_state(
+        self,
+        utc_now: datetime.datetime,
+        task: Task,
+    ) -> TaskState | None:
+        response = await self._table.get_item(
+            Key={
+                "partition_id": self._get_partition_id(task),
+                "task_id": task.canonical_name,
+            }
+        )
+
+        if "Item" not in response:
+            return None
+
+        item = response["Item"]
+
+        # For dynamic tasks, re-instantiate from spec to ensure we have fresh parameters
+        if task.parent_task is not None:
+            task_spec = json.loads(item["task_spec"]) if item.get("task_spec") else None
+            if not task_spec:
+                raise PyncetteException(f"Task {task.canonical_name} has no task_spec stored")
+            instantiated_task = task.parent_task.instantiate_from_spec(task_spec)
+        else:
+            # Static task - use as-is (no task_spec stored)
+            instantiated_task = task
+
+        execute_after = item.get("execute_after")
+        assert execute_after is not None, "execute_after should not be None for existing tasks"
+        scheduled_at = datetime.datetime.fromisoformat(execute_after)
+
+        return TaskState(
+            task=instantiated_task,
+            scheduled_at=scheduled_at,
+            locked_until=datetime.datetime.fromisoformat(item["locked_until"]) if item.get("locked_until") else None,
+            locked_by=item.get("locked_by"),
+        )
+
+    async def list_task_states(
+        self,
+        utc_now: datetime.datetime,
+        parent_task: Task,
+        limit: int | None = None,
+        continuation_token: ContinuationToken | None = None,
+    ) -> ListTasksResponse:
+        if limit is None:
+            limit = self._batch_size
+
+        # Query DynamoDB on partition_id (which encodes parent_name)
+        prefix = (self._partition_prefix or "").replace(":", "::")
+        partition_id = f"{prefix}:{parent_task.canonical_name}"
+
+        query_kwargs: dict[str, Any] = {
+            "KeyConditionExpression": Key("partition_id").eq(partition_id),
+            "Limit": limit,
+        }
+
+        if continuation_token is not None:
+            query_kwargs["ExclusiveStartKey"] = continuation_token
+
+        response = await self._table.query(**query_kwargs)
+
+        tasks = []
+        for item in response.get("Items", []):
+            task_spec = json.loads(item["task_spec"]) if item.get("task_spec") else None
+            if not task_spec:
+                logger.warning(f"Task {item['task_id']} has no task_spec, skipping")
+                continue
+
+            instantiated_task = parent_task.instantiate_from_spec(task_spec)
+
+            execute_after = item.get("execute_after")
+            assert execute_after is not None, "execute_after should not be None for existing tasks"
+            scheduled_at = datetime.datetime.fromisoformat(execute_after)
+
+            tasks.append(
+                TaskState(
+                    task=instantiated_task,
+                    scheduled_at=scheduled_at,
+                    locked_until=datetime.datetime.fromisoformat(item["locked_until"]) if item.get("locked_until") else None,
+                    locked_by=item.get("locked_by"),
+                )
+            )
+
+        next_token = ContinuationToken(response["LastEvaluatedKey"]) if "LastEvaluatedKey" in response else None
+
+        return ListTasksResponse(
+            tasks=tasks,
+            continuation_token=next_token,
+        )
+
     async def extend_lease(self, utc_now: datetime.datetime, task: Task, lease: Lease) -> Lease | None:
         assert isinstance(lease, _TaskRecord)
         record: _TaskRecord | None = cast(_TaskRecord, copy.copy(lease))
 
@@ -109,6 +109,24 @@ class QueryResponse:
     continuation_token: ContinuationToken | None
 
 
+@dataclass
+class TaskState:
+    """The state of a dynamic task instance"""
+
+    task: pyncette.task.Task
+    scheduled_at: datetime.datetime
+    locked_until: datetime.datetime | None
+    locked_by: str | None
+
+
+@dataclass
+class ListTasksResponse:
+    """The result of listing dynamic task instances"""
+
+    tasks: list[TaskState]
+    continuation_token: ContinuationToken | None
+
+
 if TYPE_CHECKING:
     import pyncette
     import pyncette.task