---
version: "2026"
language: "en"
---
# Set up Datadog for Leapwork Go

This guide shows you how to connect Leapwork Go to Datadog so you can monitor run results with Datadog dashboards. You will create an API key, configure the connection, and verify that metrics flow into Datadog.

Use this guide when you want to send Leapwork Go run data latency, throughput, error rates, and status codes to Datadog for visualization and alerting.

## Prerequisites

Before you begin, make sure you have:

* A Datadog account

* A Datadog API key (or the ability to create one)

* A Leapwork Go company with access to **Settings → App Monitoring**

* At least one completed run in Leapwork Go (for validation)

## Create a Datadog API key

1. Open **Organization Settings** in Datadog.

2. Select **API Keys**.

3. Select **New Key**.

4. Copy the full API key immediately --- you cannot retrieve it later.

> **Note:** Leapwork Go requires a Datadog **API Key** , not an **Application Key** . Use the Datadog site that matches your account region --- for example, `datadoghq.com` (US) or `datadoghq.eu` (EU).

## Add the Datadog connection in Leapwork Go

1. Open **Settings → App Monitoring** in Leapwork Go.

2. Select the **Datadog APM** provider tile.

3. Fill in the connection details using the values below.

4. Select **Save**.

### Recommended values

|            Field            |                     Value                      |
|-----------------------------|------------------------------------------------|
| Provider                    | `Datadog APM`                                  |
| Connection name             | `Primary Datadog APM`                          |
| Site                        | `datadoghq.com` or `datadoghq.eu`              |
| Description                 | Optional                                       |
| API key                     | Your Datadog API key                           |
| Metric namespace            | `lp.run_results`                               |
| Default tags                | Optional --- for example, `env:prod,team:perf` |
| Enable automatic publishing | `true`                                         |

Example stored configuration:

    {
      "site": "datadoghq.eu",
      "apiKey": "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
      "defaultTags": ["env:prod", "team:perf"],
      "metricNamespace": "lp.run_results"
    }

## Understand how publishing works

Leapwork Go publishes metrics to Datadog automatically when a run reaches a terminal state: **Finished** , **Stopped** , or **Failed**.

The backend checks whether your company has an enabled Datadog connection. If it does, Leapwork Go sends metrics to:

    https://api.<site>/api/v1/series

For example:

    https://api.datadoghq.eu/api/v1/series

## Metric catalog

Leapwork Go publishes the following metric groups.

### Per-step terminal metrics

These metrics are emitted for each step in each selected track item after a run completes.  

|               Metric               |            Description             |
|------------------------------------|------------------------------------|
| `lp.run_results.requests_sent`     | Total requests sent for the step   |
| `lp.run_results.errors`            | Total failed requests for the step |
| `lp.run_results.bytes_sent`        | Total request body bytes sent      |
| `lp.run_results.bytes_received`    | Total response bytes received      |
| `lp.run_results.latency.min_ms`    | Minimum latency in milliseconds    |
| `lp.run_results.latency.avg_ms`    | Average latency in milliseconds    |
| `lp.run_results.latency.median_ms` | Median latency in milliseconds     |
| `lp.run_results.latency.p90_ms`    | P90 latency in milliseconds        |
| `lp.run_results.latency.p95_ms`    | P95 latency in milliseconds        |
| `lp.run_results.latency.p99_ms`    | P99 latency in milliseconds        |
| `lp.run_results.latency.max_ms`    | Maximum latency in milliseconds    |

### Run-level summary metrics

These metrics are emitted once per run from the weighted summary data.  

|                Metric                |            Description            |
|--------------------------------------|-----------------------------------|
| `lp.run_results.run.latency.avg_ms`  | Weighted run-wide average latency |
| `lp.run_results.run.latency.p90_ms`  | Weighted run-wide P90 latency     |
| `lp.run_results.run.latency.p95_ms`  | Weighted run-wide P95 latency     |
| `lp.run_results.run.latency.p99_ms`  | Weighted run-wide P99 latency     |
| `lp.run_results.run.peak_throughput` | Peak throughput for the run       |
| `lp.run_results.run.error_rate_pct`  | Run-wide error rate percentage    |
| `lp.run_results.run.runtime_seconds` | Run duration in seconds           |
| `lp.run_results.run.peak_load`       | Peak virtual users for the run    |

### Track-item summary metrics

These metrics are emitted from aggregated track-item statistics.  

|                      Metric                       |             Description              |
|---------------------------------------------------|--------------------------------------|
| `lp.run_results.track_item.total_sequences_run`   | Total sequences completed            |
| `lp.run_results.track_item.throughput`            | Throughput for the run or track item |
| `lp.run_results.track_item.current_virtual_users` | Current virtual users                |
| `lp.run_results.track_item.alive_agents`          | Number of alive agents               |
| `lp.run_results.track_item.running_sequences`     | Sequences still running              |
| `lp.run_results.track_item.vum_used`              | Virtual User Minutes (VUM) consumed  |

### Historical timeseries metrics

These metrics are emitted from historical `run_data` graph points so Datadog can display the run over time.  

|                     Metric                      |                Description                 |
|-------------------------------------------------|--------------------------------------------|
| `lp.run_results.timeseries.requests_per_second` | Requests over time for a track item        |
| `lp.run_results.timeseries.latency.avg_ms`      | Average latency over time for a track item |

### Status-code breakdown metrics

These metrics are emitted from aggregated step status-code counts.  

|               Metric               |                  Description                  |
|------------------------------------|-----------------------------------------------|
| `lp.run_results.status_code.count` | Count of responses for a specific status code |

## Tags added to metrics

Leapwork Go adds tags to every metric so you can filter, group, and build dashboards.

### Base tags

These tags appear on most or all published metrics.  

|         Tag         |      Description       |
|---------------------|------------------------|
| `run_id`            | Leapwork Go run ID     |
| `run_status`        | Terminal run status    |
| `company_id`        | Leapwork Go company ID |
| `project_id`        | Project ID             |
| `timeline_asset_id` | Timeline asset ID      |
| `timeline_name`     | Timeline title         |

### Step-level tags

These tags appear on per-step metrics.  

|          Tag          |                   Description                   |
|-----------------------|-------------------------------------------------|
| `track_item_id`       | Track item ID                                   |
| `step_id`             | Step ID                                         |
| `step_title`          | Step title                                      |
| `track_item_selected` | Whether the track item was selected for the run |

### Track-item and status-code tags

These tags appear where applicable.  

|      Tag       |                   Description                    |
|----------------|--------------------------------------------------|
| `geo_location` | Track item geo location                          |
| `status_code`  | HTTP status code --- for example, `200` or `500` |

### Default tags

Any default tags you configured on the connection are also attached. For example:

* `env:prod`

* `team:perf`

## Example metrics and tags

### Per-step metric

    metric: lp.run_results.latency.p95_ms
    value: 821
    tags:
      run_id:r8_ynth
      run_status:finished
      company_id:v_smt_rpx
      project_id:abc123
      timeline_asset_id:new_timeline
      timeline_name:new_timeline
      track_item_id:track1
      step_id:step_login
      step_title:login
      track_item_selected:true
      geo_location:northeurope
      env:prod
      team:perf

### Run summary metric

    metric: lp.run_results.run.peak_throughput
    value: 642
    tags:
      run_id:r8_ynth
      run_status:finished
      company_id:v_smt_rpx
      project_id:abc123
      timeline_asset_id:new_timeline
      timeline_name:new_timeline

### Track-item summary metric

    metric: lp.run_results.track_item.vum_used
    value: 150
    tags:
      run_id:r8_ynth
      run_status:finished
      company_id:v_smt_rpx
      project_id:abc123
      timeline_name:new_timeline

### Timeseries metric

    metric: lp.run_results.timeseries.latency.avg_ms
    value: 412
    timestamp: 1713701900
    tags:
      run_id:r8_ynth
      run_status:finished
      company_id:v_smt_rpx
      project_id:abc123
      timeline_name:new_timeline
      track_item_id:track1
      geo_location:northeurope

### Status-code metric

    metric: lp.run_results.status_code.count
    value: 638
    tags:
      run_id:r8_ynth
      run_status:finished
      company_id:v_smt_rpx
      project_id:abc123
      timeline_name:new_timeline
      track_item_id:track1
      step_id:step_login
      step_title:login
      status_code:200
      geo_location:northeurope

### Check Datadog API key usage

Open **API Keys** in Datadog. Your key should show usage after Leapwork Go publishes metrics.

### Check Datadog Metrics Explorer

Search for any of these metrics to confirm data is arriving:

* `lp.run_results.latency.avg_ms`

* `lp.run_results.run.latency.p95_ms`

* `lp.run_results.timeseries.requests_per_second`

* `lp.run_results.status_code.count`

## Create a Datadog dashboard

### Create the dashboard

1. Open **Dashboards** in Datadog.

2. Select **New Dashboard**.

3. Enter a name --- for example, **Leapwork Go Dashboard**.

### Recommended widgets

**Widget 1 --- Run P95 latency**

* Widget type: `Timeseries`

* Metric: `lp.run_results.run.latency.p95_ms`

**Widget 2 --- Run average latency**

* Widget type: `Timeseries`

* Metric: `lp.run_results.run.latency.avg_ms`

**Widget 3 --- Run peak throughput**

* Widget type: `Query Value` or `Timeseries`

* Metric: `lp.run_results.run.peak_throughput`

**Widget 4 --- Run error rate**

* Widget type: `Query Value` or `Timeseries`

* Metric: `lp.run_results.run.error_rate_pct`

**Widget 5 --- Step latency**

* Widget type: `Timeseries`

* Metric: `lp.run_results.latency.p95_ms`

* Group by: `step_title`

**Widget 6 --- Status-code table**

* Widget type: `Top List`, `Table`, or `Bar Chart`

* Metric: `lp.run_results.status_code.count`

* Group by: `status_code`

**Widget 7 --- Track-item throughput over time**

* Widget type: `Timeseries`

* Metric: `lp.run_results.timeseries.requests_per_second`

* Group by: `track_item_id`

**Widget 8 --- Track-item latency over time**

* Widget type: `Timeseries`

* Metric: `lp.run_results.timeseries.latency.avg_ms`

* Group by: `track_item_id`

### Recommended dashboard filters

Add dashboard template variables for:

* `run_status`

* `timeline_name`

* `project_id`

* `track_item_id`

* `geo_location`

* `status_code`

> **Note:** `run_id` is high-cardinality and may not display well as a dashboard variable. Use it as a widget-level filter when investigating a specific run.

### Example widget queries

**Run P95 latency**

    avg:lp.run_results.run.latency.p95_ms{*}

**Step P95 latency by step title**

    avg:lp.run_results.latency.p95_ms{*} by {step_title}

**Requests per second by track item**

    avg:lp.run_results.timeseries.requests_per_second{*} by {track_item_id}

**Status-code counts by code**

    sum:lp.run_results.status_code.count{*} by {status_code}

### Understand graph differences

Leapwork Go front-end graphs use custom scaling for some overlays. Datadog charts do not reproduce that scaling automatically.

Differences you may notice:

* Leapwork Go can scale latency and throughput independently on the same chart.

* Datadog `Timeseries` widgets plot real metric values on the Y-axis.

* Two different units may look visually different in Datadog --- this is expected.

To work around this:

* Use separate widgets for latency and throughput.

* Use Datadog formulas or normalization for visualization-only graphs.

## Troubleshooting

### Datadog connection is missing `apiKey`

**Symptom:** Publishing fails with an error about a missing API key.

**Likely cause:** JSON property casing mismatch or the API key was not saved in the connection configuration.

**Fix:**

1. Open the stored connection configuration.

2. Confirm it contains the `apiKey` property.

3. Confirm the backend deserializes the configuration case-insensitively.

### Metrics not visible in Datadog

**Check these in order:**

1. The Datadog connection is enabled in Leapwork Go.

2. The **Site** value is correct --- for example, `datadoghq.eu`.

3. The API key is valid.

4. A Leapwork Go run has completed.

### Dashboard filter tags do not appear

Datadog does not always surface custom metric tags immediately.

**Try these steps:**

1. Complete another run in Leapwork Go.

2. Wait a few minutes for Datadog to index the tags.

3. Reopen the dashboard variable editor.

4. Use widget-level tag filters if the dashboard variable still does not show the tag.