Skip to main content
The Hatchet dashboard gives you a real-time view of everything happening in your system: task runs, workflow runs, active workers, and queue metrics. You can filter, inspect, cancel, and replay runs directly from the browser — or programmatically via the hatchet.runs and hatchet.metrics clients.

​
Accessing the dashboard

Log in at cloud.onhatchet.run. The dashboard is available immediately after creating a tenant.

​
Task run views

The Runs page lists all task and workflow runs for your tenant. You can filter by:
  • Status — QUEUED, RUNNING, COMPLETED, FAILED, CANCELLED
  • Workflow — narrow to a specific workflow by name
  • Time range — set a start and end time to scope the list
  • Additional metadata — key/value pairs attached when the run was triggered
Click any row to open the run detail view, which shows the task input, output, error (if any), retry count, timing, and the worker that processed it.
The dashboard polls for updates in real time. You do not need to refresh the page to see newly completed or failed runs.

​
Workflow run timeline

For multi-task workflows (DAGs), the run detail page renders the full DAG as a timeline. Each task appears as a node in the graph, colored by status. You can see which tasks ran in parallel, how long each took, and which tasks were skipped due to conditions. Click a task node to jump directly to its log output, input, and output payload.

​
Worker status

The Workers page shows all workers currently connected to the server. For each worker you can see:
  • Name and ID
  • Active slots — how many tasks the worker is running versus its configured capacity
  • Labels — key/value metadata attached when the worker was created (used by affinity rules)
  • Last heartbeat — the most recent time the worker checked in
A worker disappears from the list if it stops sending heartbeats. Its in-flight tasks are moved back to the queue.

​
Metrics

The Metrics page surfaces tenant-wide queue and task throughput data:
  • Queue depth — the number of tasks currently waiting in each queue
  • Task throughput — counts of completed, failed, queued, running, and cancelled tasks over a time window
  • Error rates — the proportion of failed runs over time
Metrics update in real time and are also available programmatically (see below).

​
Programmatic access via hatchet.runs

You can query and manage runs from your own code using the hatchet.runs client. This is useful for building scripts, dashboards, or automation on top of the same data you see in the UI.

​
Listing runs

from datetime import datetime, timedelta, timezone
from hatchet_sdk import Hatchet
from hatchet_sdk.clients.rest.models.v1_task_status import V1TaskStatus

hatchet = Hatchet()

# List runs from the past hour
runs = hatchet.runs.list(
    since=datetime.now(timezone.utc) - timedelta(hours=1),
    statuses=[V1TaskStatus.FAILED],
)

for run in runs.rows:
    print(run.metadata.id, run.status)
For date ranges longer than 7 days, use list_with_pagination to avoid performance issues:
runs = hatchet.runs.list_with_pagination(
    since=datetime.now(timezone.utc) - timedelta(days=30),
    statuses=[V1TaskStatus.FAILED],
)
Calling list with a date range longer than 7 days emits a RuntimeWarning. Use list_with_pagination or aio_list_with_pagination for large ranges.

​
Filtering by additional metadata

runs = hatchet.runs.list(
    since=datetime.now(timezone.utc) - timedelta(hours=24),
    additional_metadata={"user_id": "usr_123"},
)

​
Getting a single run

# Get workflow run details (includes task-level breakdown)
details = hatchet.runs.get(workflow_run_id)

# Get a specific task run
task = hatchet.runs.get_task_run(task_run_id)

# Get just the status of a workflow run
status = hatchet.runs.get_status(workflow_run_id)

​
Cancelling runs

from hatchet_sdk.features.runs import BulkCancelReplayOpts, RunFilter
from hatchet_sdk.clients.rest.models.v1_task_status import V1TaskStatus

# Cancel a single run
hatchet.runs.cancel(run_id)

# Bulk cancel by IDs
hatchet.runs.bulk_cancel(
    opts=BulkCancelReplayOpts(ids=[run_id_1, run_id_2])
)

# Bulk cancel by filter (running tasks in the past hour)
hatchet.runs.bulk_cancel(
    opts=BulkCancelReplayOpts(
        filters=RunFilter(
            since=datetime.now(timezone.utc) - timedelta(hours=1),
            statuses=[V1TaskStatus.RUNNING],
        )
    )
)

​
Replaying runs

# Replay a single run
hatchet.runs.replay(run_id)

# Bulk replay failed runs from the past day
hatchet.runs.bulk_replay_by_filters_with_pagination(
    since=datetime.now(timezone.utc) - timedelta(days=1),
    statuses=[V1TaskStatus.FAILED],
)

​
Programmatic access via hatchet.metrics

The hatchet.metrics client exposes the same metrics shown in the dashboard. 
from datetime import datetime, timedelta, timezone
from hatchet_sdk import Hatchet

hatchet = Hatchet()

# Queue depth per queue
queues = hatchet.metrics.get_queue_metrics()
print(queues)

# Task counts by status (past 24 hours by default)
task_metrics = hatchet.metrics.get_task_metrics()
print(task_metrics.queued, task_metrics.running, task_metrics.failed)

# Scoped to a time range or specific workflows
task_metrics = hatchet.metrics.get_task_metrics(
    since=datetime.now(timezone.utc) - timedelta(hours=6),
    workflow_ids=["my-workflow-id"],
)

# Raw Prometheus metrics for scraping
prometheus_text = hatchet.metrics.scrape_tenant_prometheus_metrics()
All methods have async equivalents prefixed with aio_:
task_metrics = await hatchet.metrics.aio_get_task_metrics()

​
Next steps

Task logs

Capture and query logs from individual task runs.

Alerting

Get notified via Slack or email when tasks fail.

OpenTelemetry

Export traces to your observability platform.

Build docs developers (and LLMs) love

Get started for freeTalk to us