---
description: Set up the Datadog MCP server for Claude Code, Cursor, and AI agents, then route it through Bifrost for shared auth, tool filtering, and audit logs.
title: "Datadog MCP Server: Setup, Toolsets, and Governed Access for AI Agents"
image: https://storage.ghost.io/c/84/03/8403f2f6-141c-411a-8f55-a32d4291533e/content/images/size/w1200/2026/11/datadog-mcp-server-setup-toolsets-and-governed-access-for-ai-bifrost-1920x1080.png
---

Try Bifrost Enterprise free for 14 days. [Request access](https://www.getmaxim.ai/#enterprise-trial)

**TL;DR**

- The Datadog MCP server is a remote MCP endpoint that lets AI clients and agents query Datadog logs, metrics, traces, monitors, incidents, dashboards, and more.
- It exposes a `core` toolset by default and dozens of optional product toolsets, selected with a `toolsets` query parameter or the `X-Datadog-MCP-Toolsets` header.
- It authenticates with OAuth or with `DD_API_KEY` and `DD_APPLICATION_KEY` headers, so access follows the permissions of the user or keys behind each connection.
- Connecting every AI client directly spreads keys and full tool access across laptops and agents, with no single record of which tool was called.
- Routing the Datadog MCP server through Bifrost centralizes credentials, filters tools per team or agent, and logs every call; the Bifrost Datadog plugin also sends gateway traces and LLM Observability data back to Datadog.

The Datadog MCP server gives AI coding assistants and agents direct access to production telemetry, which makes it one of the most useful MCP servers for engineering teams and one of the most sensitive. [Bifrost](https://www.getmaxim.ai), the [open-source AI gateway](https://github.com/maximhq/bifrost) built by Maxim AI, sits between AI clients and the Datadog MCP server so teams can decide which tools each agent sees and keep a record of every call. This guide covers Datadog MCP setup, toolsets, authentication, and a governed rollout through Bifrost.

## What Is the Datadog MCP Server?

The Datadog MCP server is a Datadog-managed, remote Model Context Protocol server that exposes Datadog data and actions as tools for AI clients. An agent connected to it can search logs, pull metrics, read traces, list monitors and incidents, and work with notebooks and dashboards, all through natural-language requests that the model turns into tool calls.

Typical Datadog MCP uses:

- **Incident triage.** Ask an agent to pull recent error logs, related traces, and the monitors that fired for a service.
- **Debugging from the editor.** A coding agent in Claude Code or Cursor checks production errors for the function it is changing.
- **Reporting.** Summarize SLO status or incident timelines into a notebook.
- **On-call assistants.** Internal agents answer "what changed?" questions across metrics, events, and deployments.

Datadog publishes [setup instructions for the MCP server](https://docs.datadoghq.com/mcp_server/setup/) for Claude, ChatGPT, Codex, Cursor, VS Code, and other clients.

The [Bifrost MCP server directory](https://www.getmaxim.ai/mcp-servers) lists setup guides for other servers teams often pair with it, such as [GitHub](https://www.getmaxim.ai/mcp-servers/github) and [Sentry](https://www.getmaxim.ai/mcp-servers/sentry).

## Datadog MCP Toolsets and Tools

The Datadog MCP server organizes its tools into toolsets. Only the `core` toolset is enabled by default, covering logs, metrics, traces, dashboards, monitors, incidents, hosts, services, events, and notebooks. Product toolsets such as APM, Alerting, Security, Database Monitoring, Synthetics, and Cloud Cost Management are added by naming them in the connection.

The [Datadog MCP tools reference](https://docs.datadoghq.com/mcp_server/tools/) lists more than 400 tools across these toolsets. A few examples from the core set:

| Tool | What it does | Access type |
| --- | --- | --- |
| `search_datadog_logs` | Searches logs with a query and time range | Read |
| `get_datadog_metric` | Retrieves metric time series | Read |
| `get_datadog_trace` | Fetches a distributed trace | Read |
| `search_datadog_monitors` | Lists monitors and their status | Read |
| `search_datadog_incidents` | Lists incidents | Read |
| `create_datadog_notebook` | Creates a notebook | Write |
| `delete_datadog_notebook` | Deletes a notebook | Write |

Toolsets are selected in two ways:

- **Query parameter.** Append `?toolsets=apm,llmobs` to the endpoint URL, or `?toolsets=all` for every generally available toolset.
- **Header.** Send `X-Datadog-MCP-Toolsets: apm,llmobs` on the connection.

Enabling `all` gives agents the widest reach but also the largest tool list, which costs context and makes tool selection harder. The guide to [how MCP tools work](https://www.getmaxim.ai/articles/how-mcp-tools-work-discovery-invocation-and-access-control/) explains why large tool lists matter.

## How Datadog MCP Authentication Works

The Datadog MCP server supports two authentication methods: an OAuth login flow, where each user signs in to Datadog in a browser, and API key authentication, where the client sends a Datadog API key and application key as `DD_API_KEY` and `DD_APPLICATION_KEY` headers. Either way, tool calls run with the Datadog permissions of the signed-in user or the keys provided.

Practical implications:

- **Pick the right site.** Each Datadog site has its own endpoint, such as `https://mcp.datadoghq.com/v1/mcp` for US1 and `https://mcp.datadoghq.eu/v1/mcp` for EU.
- **Application keys carry permissions.** An application key acts with the permissions of the user or service account that created it, so a key from an admin account gives agents admin reach.
- **Keys sprawl quickly.** If every developer pastes keys into their own client config, revoking or rotating access means finding every copy.

Datadog documents [API and application keys](https://docs.datadoghq.com/account_management/api-app-keys/) and their scopes. Teams that want each engineer to keep their own Datadog identity, without storing keys on laptops, can use per-user credentials at the gateway; the [Bifrost MCP authentication overview](https://docs.getbifrost.ai/mcp/auth/overview) lists every option.

## Direct Connections vs a Gateway

Connecting each AI client directly to the Datadog MCP server is the fastest way to start, but it scales poorly. Every client holds its own keys, sees whatever toolsets it enabled, and logs nothing centrally. Routing through a gateway such as Bifrost keeps one connection to Datadog, scopes tools per team or agent, and records every call.

Figure 1 compares the two setups.

![Top: Claude Code, Cursor, and agents each connect straight to the Datadog MCP server with their own keys. Bottom: all clients connect through Bifrost, which holds credentials and filters tools](https://articles-images-cdn.t3.tigrisfiles.io/diagrams/datadog-mcp-server/datadog-mcp-direct-vs-gateway.png)

Top: Claude Code, Cursor, and agents each connect straight to the Datadog MCP server with their own keys. Bottom: all clients connect through Bifrost, which holds credentials and filters tools

*Figure 1: Direct connections spread Datadog keys and tool access across every client; routing through a gateway keeps credentials, tool filtering, and logs in one place.*

| Concern | Direct connection | Through Bifrost |
| --- | --- | --- |
| **Credentials** | Keys in each client config | Held in Bifrost (encrypted at rest with an encryption key set) or supplied per user |
| **Tool access** | Whatever toolsets each client enables | Filtered per MCP client, per request, and per virtual key |
| **Write tools** | Available if the key allows them | Can be removed from the tool list entirely |
| **Audit trail** | Spread across clients, if kept at all | Every tool call logged alongside the model request that produced it |
| **Rotation** | Update every client | Update once in Bifrost |

The comparison of [MCP gateways vs MCP proxies vs MCP servers](https://www.getmaxim.ai/articles/mcp-gateway-vs-mcp-proxy-vs-mcp-server-key-differences/) covers the architecture, and the [risks of ungoverned MCP server access](https://www.getmaxim.ai/articles/5-security-risks-of-ungoverned-mcp-server-access/) covers what goes wrong without one.

## How to Connect the Datadog MCP Server to Bifrost

Connecting the Datadog MCP server to Bifrost takes five steps: pick the endpoint and toolsets, choose an authentication model, register the server as an HTTP MCP client, filter its tools, and attach it to the virtual keys your clients use. After that, every AI client reaches Datadog through the [Bifrost MCP gateway](https://www.getmaxim.ai/mcp-gateway) instead of connecting on its own.

![Five steps in a row: pick the Datadog site endpoint, choose an auth model, register the server in Bifrost, filter tools, then attach it to virtual keys for clients](https://articles-images-cdn.t3.tigrisfiles.io/diagrams/datadog-mcp-server/datadog-mcp-setup.png)

Five steps in a row: pick the Datadog site endpoint, choose an auth model, register the server in Bifrost, filter tools, then attach it to virtual keys for clients

*Figure 2: Five steps take the Datadog MCP server from a raw endpoint to a governed tool set that every AI client reaches through Bifrost.*

### Step 1: Pick the endpoint and toolsets

Use the endpoint for your Datadog site and add only the toolsets your use case needs. For an incident-triage agent, `core` plus APM is a sensible start:

```
<https://mcp.datadoghq.com/v1/mcp?toolsets=core,apm>
```

### Step 2: Choose an authentication model

Bifrost supports several [upstream authentication modes](https://docs.getbifrost.ai/mcp/auth/overview) for MCP servers. Two fit Datadog well:

- **Shared service account.** [Header authentication](https://docs.getbifrost.ai/mcp/auth/headers) attaches one set of Datadog keys to every call. Create the keys on a read-only service account so the scope is explicit.
- **Per-engineer keys.** [Per-user headers](https://docs.getbifrost.ai/mcp/auth/per-user-headers) let each user submit their own `DD_API_KEY` and `DD_APPLICATION_KEY`, stored encrypted per identity, so tool calls keep each person's Datadog permissions.

### Step 3: Register the server in Bifrost

Add the Datadog MCP server as an HTTP client through the Bifrost dashboard (**MCP Gateway**, then **New MCP Server**) or the API. With shared headers, the values reference environment variables so keys stay out of config files:

```bash
curl -X POST <http://localhost:8080/api/mcp/client> \
  -H "Content-Type: application/json" \
  -d '{
    "name": "datadog",
    "connection_type": "http",
    "connection_string": "<https://mcp.datadoghq.com/v1/mcp?toolsets=core,apm>",
    "auth_type": "headers",
    "headers": {
      "DD_API_KEY": "env.DD_API_KEY",
      "DD_APPLICATION_KEY": "env.DD_APPLICATION_KEY"
    },
    "tools_to_execute": ["*"]
  }'
```

The [MCP server connection guide](https://docs.getbifrost.ai/mcp/connecting-to-servers) covers the other connection options, including session stickiness for HTTP clients.

### Step 4: Filter the tools

Replace the `*` in `tools_to_execute` with an explicit list, starting read-only:

```json
"tools_to_execute": [
  "search_datadog_logs",
  "get_datadog_metric",
  "get_datadog_trace",
  "search_datadog_monitors",
  "search_datadog_incidents"
]
```

[Tool filtering](https://docs.getbifrost.ai/mcp/filtering) also applies per request and per virtual key, and a tool must pass every applicable filter to be visible.

### Step 5: Attach it to virtual keys and connect clients

Give each team or agent a [virtual key](https://docs.getbifrost.ai/features/governance/virtual-keys) with the Datadog tools it needs, or bundle Datadog tools with other servers in a [Virtual MCP](https://docs.getbifrost.ai/mcp/virtual-mcps) served at its own `/mcp/<slug>` endpoint. Clients then connect to Bifrost, for example from Claude Code:

```bash
claude mcp add --transport http bifrost <https://bifrost.example.com/mcp> \
  --header "x-bf-vk: sk-bf-your-virtual-key"
```

[Gateway authentication](https://docs.getbifrost.ai/mcp/gateway-auth) also supports browser-based OAuth 2.1 for interactive clients.

## Governing Datadog MCP Access

Governing Datadog MCP access means deciding which agents can read which data, keeping write actions behind deliberate approval, and being able to show what every agent did. Production telemetry often contains customer identifiers, internal hostnames, and sometimes secrets in log lines, so the defaults matter.

Controls to set in Bifrost:

- **Read-only by default.** Expose search and get tools; add create, edit, and delete tools only for agents that need them.
- **Scope by team.** An SRE agent can see APM and incident tools; a coding agent may only need logs and traces for its own services.
- **Explicit execution.** Tool calls from models are suggestions by default, and [agent mode](https://docs.getbifrost.ai/mcp/agent-mode) auto-execution has to be configured per tool.
- **Role-based administration.** [RBAC](https://docs.getbifrost.ai/enterprise/rbac) and [access profiles](https://docs.getbifrost.ai/enterprise/access-profiles) in Bifrost Enterprise control who can change MCP servers, keys, and policies.

Content checks on tool traffic:

- **Secrets in results.** [Secrets detection](https://docs.getbifrost.ai/enterprise/guardrails/secrets-detection) can flag or redact credentials that appear in log lines returned to the model.
- **MCP guardrails.** The post on [MCP guardrails in Bifrost](https://www.getmaxim.ai/bifrost/blog/mcp-guardrails-in-bifrost/) covers rules that run on tool inputs and outputs.

The guide to [MCP server governance best practices](https://www.getmaxim.ai/articles/mcp-server-governance-best-practices-and-tools/) covers policy design across servers.

## Sending Bifrost Telemetry Back to Datadog

Datadog also works in the other direction. The Bifrost Datadog plugin sends gateway telemetry into Datadog, so the same platform that agents query through the MCP server also records every model and tool request the gateway handles. Teams get Datadog MCP access for agents and Datadog visibility into the agents themselves.

![Agents query Datadog through Bifrost and the Datadog MCP server, while the Bifrost Datadog plugin sends APM traces, LLM Observability spans, and metrics back into Datadog](https://articles-images-cdn.t3.tigrisfiles.io/diagrams/datadog-mcp-server/datadog-two-directions.png)

Agents query Datadog through Bifrost and the Datadog MCP server, while the Bifrost Datadog plugin sends APM traces, LLM Observability spans, and metrics back into Datadog

*Figure 3: Agents read from Datadog through the MCP server, and the Datadog plugin writes gateway traces and LLM Observability data back, so the same platform sees both sides.*

What the [Bifrost Datadog integration](https://docs.getbifrost.ai/features/observability/datadog) sends:

- **APM traces** through dd-trace-go v2, with W3C Trace Context for end-to-end request visibility.
- **LLM Observability spans** through the native Datadog LLM Observability integration.
- **Metrics** through DogStatsD or the Datadog Metrics API.

It runs in **agent mode**, through a local Datadog Agent, or **agentless mode**, sending directly to Datadog APIs with an API key. Options such as `disable_content_logging` drop message content from exported spans when payloads should not leave the gateway. Teams on other stacks can use [OpenTelemetry export](https://docs.getbifrost.ai/features/observability/otel) instead.

## Auditing Datadog Tool Calls

Every Datadog tool call that passes through Bifrost is logged with the model request that produced it, the virtual key that made it, and the result. That record answers the questions security and platform teams ask after an incident: which agent queried which data, when, and on whose behalf.

What the record supports:

- **Investigations.** Trace a surprising notebook edit or monitor change back to the agent and user.
- **Access reviews.** See which teams actually use which Datadog tools before widening or narrowing scopes.
- **Cost attribution.** Tool calls sit next to the token cost of the model calls that triggered them.

Bifrost [request logs](https://docs.getbifrost.ai/features/observability/default) hold the per-request data, and [audit logs](https://docs.getbifrost.ai/enterprise/audit-logs) track administrative changes such as adding a server or editing a tool filter.

The guide to [auditing every AI tool call](https://www.getmaxim.ai/articles/mcp-gateway-observability-audit-every-ai-tool-call/) and the post on [MCP audit logging requirements](https://www.getmaxim.ai/bifrost/blog/mcp-audit-logging-requirements-for-enterprise-governance-and-compliance/) cover retention and compliance.

## Datadog MCP Best Practices

A Datadog MCP rollout goes well when access starts narrow and widens with evidence. The same few practices apply whether the first users are a handful of SREs in Claude Code or a fleet of internal agents.

- **Start with `core`** and add product toolsets only when a use case needs them.
- **Use a dedicated service account** with read-only permissions for shared keys.
- **Keep keys out of client configs**; store them in Bifrost as environment-variable references or use per-user headers.
- **Separate read and write.** Put write tools on a different virtual key or Virtual MCP that only specific agents receive.
- **Review usage monthly** from tool-call logs and remove tools nobody uses.
- **Watch context size.** Large toolsets inflate prompts; [Code Mode](https://docs.getbifrost.ai/mcp/code-mode) keeps tool definitions out of context for multi-step work.

For more on running many servers side by side, see [remote MCP server gateways](https://www.getmaxim.ai/articles/remote-mcp-server-gateways/) and the [Atlassian MCP server guide](https://www.getmaxim.ai/mcp-servers/atlassian).

## Frequently Asked Questions

### What is the Datadog MCP server?

The Datadog MCP server is a remote MCP endpoint managed by Datadog that exposes logs, metrics, traces, monitors, incidents, dashboards, notebooks, and product-specific data as tools for AI clients and agents. Clients such as Claude Code, Cursor, and custom agents connect to it with OAuth or API and application keys.

### How do I set up Datadog MCP in Claude Code?

You can add the Datadog endpoint for your site directly in Claude Code, or connect Claude Code to Bifrost with a virtual key and let Bifrost hold the Datadog connection. The second option keeps keys off developer machines and applies [per-key tool filters](https://docs.getbifrost.ai/mcp/filtering) and logging to every call.

### What toolsets does the Datadog MCP server support?

The `core` toolset is enabled by default and covers logs, metrics, traces, dashboards, monitors, incidents, hosts, services, events, and notebooks. Product toolsets, including APM, Alerting, Security, Database Monitoring, Synthetics, and Cloud Cost Management, are added with the `toolsets` query parameter or the `X-Datadog-MCP-Toolsets` header.

### Is the Datadog MCP server safe for production data?

It runs with the permissions of the user or keys behind each connection, so safety depends on scoping. Use read-only service accounts, enable only needed toolsets, keep write tools separate, and log every call. A gateway such as [Bifrost](https://www.getmaxim.ai/mcp-gateway) centralizes those controls.

### Can each engineer use their own Datadog permissions through Bifrost?

Yes. With per-user headers, each user submits their own Datadog API and application keys once, Bifrost stores them encrypted per identity, and tool calls run with that user's Datadog permissions. The [per-user headers guide](https://docs.getbifrost.ai/mcp/auth/per-user-headers) covers setup.

### Does Bifrost send data to Datadog?

Yes, if you enable the Datadog plugin. It sends APM traces, LLM Observability spans, and metrics for requests that pass through Bifrost, in agent or agentless mode, with options to drop message content from exported spans.

## Give Agents Datadog Access Without Losing Control

The Datadog MCP server puts production telemetry in reach of every AI client, which is exactly why access should run through one governed path. Bifrost holds the Datadog connection, filters tools per team and agent, logs every call, and sends gateway telemetry back to Datadog. To see it with your observability stack, [book a demo](https://www.getmaxim.ai/book-a-demo) with the Bifrost team.

## Read next

[![Atlassian MCP Server: Setup, Permissions, and Security for Jira and Confluence](https://storage.ghost.io/c/84/03/8403f2f6-141c-411a-8f55-a32d4291533e/content/images/size/w720/2026/11/atlassian-mcp-server-setup-permissions-and-security-for-jira-bifrost-1920x1080.png) The Atlassian MCP server lets Claude, Cursor, and other AI agents read and update Jira and Confluence. This guide covers setup, authentication, permission groups, admin controls, and how to add tool filtering, guardrails, and audit logs with an MCP gateway.](https://www.getmaxim.ai/articles/atlassian-mcp-server/)

[![10 Best AWS MCP Servers, and How to Govern Them Through One Gateway](https://storage.ghost.io/c/84/03/8403f2f6-141c-411a-8f55-a32d4291533e/content/images/size/w720/2026/11/10-best-aws-mcp-servers-and-how-to-govern-them-through-one-g-bifrost-1920x1080@2x.png) AWS MCP servers are MCP servers that AWS maintains so AI agents can read AWS docs and call AWS APIs. This guide ranks 10 of them, from the managed AWS MCP Server to the EKS, CloudWatch, and Billing servers, and shows how Bifrost governs them through one gateway.](https://www.getmaxim.ai/articles/aws-mcp-servers/)

[![MCP Server Best Practices for Reliability and Security](https://storage.ghost.io/c/84/03/8403f2f6-141c-411a-8f55-a32d4291533e/content/images/size/w720/2026/11/mcp-server-best-practices-for-reliability-and-security-bifrost-1920x1080.png) MCP server best practices cover how to design tools a model can call correctly, keep servers reliable under retries and timeouts, and secure them with scoped authorization. This guide covers what to build into each server and what to centralize in an MCP gateway.](https://www.getmaxim.ai/articles/mcp-server-best-practices/)

## More in MCP Gateway

[![Top 5 MCP Gateways for Built-in Routing and Control](https://storage.ghost.io/c/84/03/8403f2f6-141c-411a-8f55-a32d4291533e/content/images/size/w720/2026/09/top-5-mcp-gateways-for-built-in-routing-and-control-bifrost-isometric-1.png) MCP gateway routing decides which server handles each tool call; control decides whether the agent may make it. This guide compares Bifrost, Kong, Docker, Microsoft MCP Gateway, and Lasso on both](https://www.getmaxim.ai/articles/top-5-mcp-gateways-for-built-in-routing-and-control/)

[![RAG vs MCP: Key Differences and When to Use Both](https://storage.ghost.io/c/84/03/8403f2f6-141c-411a-8f55-a32d4291533e/content/images/size/w720/2026/11/rag-vs-mcp-key-differences-and-when-to-use-both-bifrost-1920x1080.png) RAG vs MCP comes down to timing: RAG retrieves documents before the model generates, while MCP lets the model call tools at runtime. This guide compares the two, explains when to combine them, and shows how to govern retrieval and tool calls together.](https://www.getmaxim.ai/articles/rag-vs-mcp-key-differences-and-when-to-use-both/)

```json
{
    "@context": "https://schema.org",
    "@type": "Article",
    "publisher": {
        "@type": "Organization",
        "name": "Maxim Articles",
        "url": "https://www.getmaxim.ai/articles/",
        "logo": {
            "@type": "ImageObject",
            "url": "https://storage.ghost.io/c/84/03/8403f2f6-141c-411a-8f55-a32d4291533e/content/images/size/w256h256/2025/08/thumbnail.png",
            "width": 60,
            "height": 60
        }
    },
    "author": {
        "@type": "Person",
        "name": "Kuldeep Paul",
        "image": {
            "@type": "ImageObject",
            "url": "https://storage.ghost.io/c/84/03/8403f2f6-141c-411a-8f55-a32d4291533e/content/images/2025/08/1727978381919.jpeg",
            "width": 800,
            "height": 800
        },
        "url": "https://www.getmaxim.ai/articles/author/kuldeep/",
        "sameAs": []
    },
    "headline": "Datadog MCP Server: Setup, Toolsets, and Governed Access for AI Agents",
    "url": "https://www.getmaxim.ai/articles/datadog-mcp-server/",
    "datePublished": "2026-11-17T01:57:00.000Z",
    "dateModified": "2026-11-21T01:57:31.000Z",
    "image": {
        "@type": "ImageObject",
        "url": "https://storage.ghost.io/c/84/03/8403f2f6-141c-411a-8f55-a32d4291533e/content/images/size/w1200/2026/11/datadog-mcp-server-setup-toolsets-and-governed-access-for-ai-bifrost-1920x1080.png",
        "width": 1200,
        "height": 675
    },
    "keywords": "MCP Gateway",
    "description": "The Datadog MCP server lets AI agents query logs, metrics, traces, monitors, and incidents. This guide covers Datadog MCP setup, toolsets, and auth, and how to route the server through Bifrost so every client gets scoped tools, managed credentials, and one log of tool calls.",
    "mainEntityOfPage": "https://www.getmaxim.ai/articles/datadog-mcp-server/"
}
```
