Set Up the Datadog MCP Server

Docs > Bits AI > Datadog MCP Server > Set Up the Datadog MCP Server

Learn how to set up and configure the Datadog MCP Server, which lets you retrieve telemetry insights and manage platform features directly from AI-powered clients. Select your client:

Install the Datadog Connector from the Claude Connectors Directory. The official connector is the recommended way to connect Datadog to Claude (including Claude Cowork) and includes MCP Apps for in-product visualizations. If you previously added Datadog as a custom connector, remove it to avoid conflicts.

In Claude, click the + icon at the bottom of any prompt, then click Add Connector.
Find Datadog in the directory and enable the connector.
Complete the OAuth login flow when prompted.
Verify that you have the required permissions for the Datadog resources you want to access.

Manual setup with a custom connector

If the directory connector is not available to you, you can add Datadog as a custom connector using the remote MCP URL for your Datadog site (). For the correct instructions, use the Datadog Site selector on the right side of this documentation page to select your site.

Follow the Claude help center guide on custom connectors to add a new custom connector.
When prompted for a URL, enter:
To enable product-specific tools, include the toolsets query parameter at the end of the endpoint URL. For example, this URL enables only APM and LLM Observability tools (use toolsets=all to enable all generally available toolsets, best for clients that support tool filtering):
```
?toolsets=apm,llmobs
```
Complete the OAuth login flow when prompted.

Install the Datadog plugin from the official Anthropic Plugin Marketplace. The plugin packages the Datadog MCP Server with bundled skills and auto-updates when new plugin versions ship. For more details, see the plugin repository. If you previously installed the Datadog MCP Server manually, remove it from your Claude Code configuration to avoid conflicts.

Install the Datadog plugin:

/plugin install datadog@claude-plugins-official

For first-time setup, either run /ddsetup or enter any Datadog-related prompt. During setup, select your Datadog site and complete OAuth login. Alternatively, set the MCP Server domain (and optionally Datadog API and application keys) as environment variables before starting Claude Code.
Run /ddtoolsets to enable or disable groups of product-specific MCP tools.
After any making any configuration change, run /reload-plugins and reauthenticate by opening /plugin and selecting the Datadog plugin.
Verify that you have the required permissions for the Datadog resources you want to access.

See the plugin repository for all available slash commands and configuration options.

Manual MCP Server configuration

If the plugin is not available to you, point Claude Code at the MCP Server endpoint for your regional Datadog site directly. Selected endpoint (): .

Run in terminal:

claude mcp add --transport http datadog-mcp

Alternatively, add to ~/.claude.json:

{
   "mcpServers": {
     "datadog": {
       "type": "http",
       "url": ""
      }
    }
 }

To enable product-specific tools, include the toolsets query parameter at the end of the endpoint URL. For example, this URL enables only APM and LLM Observability tools (use toolsets=all to enable all generally available toolsets, best for clients that support tool filtering):
```
?toolsets=apm,llmobs
```

If remote authentication is not available, use local binary authentication instead.

Point your AI agent to the MCP Server endpoint for your regional Datadog site. For the correct instructions, use the Datadog Site selector on the right side of this documentation page to select your site.

Selected endpoint (): .

Edit ~/.codex/config.toml (or your Codex CLI configuration file) to add the Datadog MCP Server with HTTP transport and the endpoint URL for your site. For example:
```
[mcp_servers.datadog]
url = ""
```
To enable product-specific tools, include the toolsets query parameter at the end of the endpoint URL. For example, this URL enables only APM and LLM Observability tools (use toolsets=all to enable all generally available toolsets, best for clients that support tool filtering):
```
?toolsets=apm,llmobs
```
Log in to the Datadog MCP Server:
```
codex mcp login datadog
```
This opens your browser to complete the OAuth flow. Codex stores the resulting credentials so you don’t need to log in again until the token expires.
Verify that you have the required permissions for the Datadog resources you want to access.

Install the Datadog Plugin from the Cursor Marketplace—the plugin includes the Datadog MCP Server and other resources. If you previously installed the Datadog MCP Server manually, remove it from the IDE’s configuration to avoid conflicts.

Connect Devin to the Datadog MCP Server by enabling it from Devin’s MCP Marketplace. For the correct instructions, use the Datadog Site selector on the right side of this documentation page to select your site.

Point your AI agent to the MCP Server endpoint for your regional Datadog site. For the correct instructions, use the Datadog Site selector on the right side of this documentation page to select your site.

Selected endpoint (): .

Run in terminal:

gemini mcp add --transport http datadog

Alternatively, add to ~/.gemini/settings.json:

{
   "mcpServers": {
     "datadog": {
       "httpUrl": ""
     }
   }
 }

To enable product-specific tools, include the toolsets query parameter at the end of the endpoint URL. For example, this URL enables only APM and LLM Observability tools (use toolsets=all to enable all generally available toolsets, best for clients that support tool filtering):
```
?toolsets=apm,llmobs
```
Verify that you have the required permissions for the Datadog resources you want to access.

If remote authentication is not available, use local binary authentication instead.

Selected endpoint (): .

Add the Datadog MCP Server to Goose using one of the following methods:
- One-click install (recommended): Use the Datadog MCP Server install deeplink.
- Manual configuration: Follow Goose’s instructions to add an MCP server, using the endpoint listed in this section as the streamable HTTP server URL. To edit the configuration directly, modify ~/.config/goose/config.yaml.
To enable product-specific tools, include the toolsets query parameter at the end of the endpoint URL. For example, this URL enables only APM and LLM Observability tools:
```
?toolsets=apm,llmobs
```
To enable all generally available toolsets, use toolsets=all. This works best for clients that support tool filtering.
On first session launch, choose your Datadog account when prompted to authenticate.
Verify that you have the required permissions for the Datadog resources you want to access.

JetBrains offers the Junie and AI Assistant plugins for their range of IDEs. GitHub offers the Copilot plugin. Alternatively, many developers use an agent CLI, such as Claude Code, Codex, or Gemini CLI, alongside their IDE.

Point your plugin to the MCP Server endpoint for your regional Datadog site. For the correct instructions, use the Datadog Site selector on the right side of this documentation page to select your site.

Selected endpoint (): .

Junie

Go to Tools > Junie > MCP Settings and add the following block:

{
   "mcpServers": {
     "datadog": {
       "type": "http",
       "url": ""
     }
   }
 }

To enable product-specific tools, include the toolsets query parameter at the end of the endpoint URL. For example, this URL enables only APM and LLM Observability tools (use toolsets=all to enable all generally available toolsets, best for clients that support tool filtering):
```
?toolsets=apm,llmobs
```
You are prompted to login through OAuth. The status indicator in the settings displays a green tick when the connection is successful.
Verify that you have the required permissions for the Datadog resources you want to access.

JetBrains AI Assistant

Go to Tools > AI Assistant > Model Context Protocol (MCP) and add the following block:

{
   "mcpServers": {
     "datadog": {
       "url": ""
       "headers": {
         "DD_API_KEY": "<YOUR_API_KEY>",
         "DD_APPLICATION_KEY": "<YOUR_APP_KEY>"
       }
     }
   }
 }

To enable product-specific tools, include the toolsets query parameter at the end of the endpoint URL. For example, this URL enables only APM and LLM Observability tools (use toolsets=all to enable all generally available toolsets, best for clients that support tool filtering):
```
?toolsets=apm,llmobs
```
The status indicator in the settings displays a green tick when the connection is successful.
Verify that you have the required permissions for the Datadog resources you want to access.

GitHub Copilot

Go to Tools > GitHub Copilot > Model Context Protocol (MCP) and add the following block:

{
   "servers": {
     "datadog": {
       "type": "http",
       "url": ""
     }
   }
 }

To enable product-specific tools, include the toolsets query parameter at the end of the endpoint URL. For example, this URL enables only APM and LLM Observability tools (use toolsets=all to enable all generally available toolsets, best for clients that support tool filtering):
```
?toolsets=apm,llmobs
```
Click the Start element that appears in the editor to start the server. You are prompted to log in through OAuth.
Verify that you have the required permissions for the Datadog resources you want to access.

Agent CLIs

Many developers use an agent CLI such as Claude Code, Codex, or Gemini CLI alongside their JetBrains IDE. See the configuration for those CLI tools:

The Datadog plugin for JetBrains IDEs integrates with these agent CLIs. For an uninterrupted experience, install the plugin at the same time as you configure the Datadog MCP Server.

Selected endpoint (): .

Add the following to your Kiro MCP configuration file (~/.kiro/settings/mcp.json for user-scoped configuration):
```
{
   "mcpServers": {
     "datadog": {
       "url": ""
     }
   }
 }
```
To enable product-specific tools, include the toolsets query parameter at the end of the endpoint URL. For example, this URL enables only APM and LLM Observability tools (use toolsets=all to enable all generally available toolsets, best for clients that support tool filtering):
```
?toolsets=apm,llmobs
```
Verify that you have the required permissions for the Datadog resources you want to access.

Connect OpenCode to the Datadog MCP Server with the official Datadog OpenCode Plugin (in Preview). The plugin writes and maintains the MCP Server entry in your opencode.json and exposes the ddsetup, ddconfig, and ddtoolsets tools that the agent uses to handle setup, site changes, and toolset selection.

Add the plugin to your opencode.json configuration file. Create the file if it doesn’t exist:
```
{
  "plugin": ["@datadog/opencode-plugin"]
}
```
If a plugin array already exists, add "@datadog/opencode-plugin" to it.
If you previously configured the Datadog MCP Server manually in opencode.json, remove or disable that entry to avoid conflicts with the plugin.
Restart OpenCode. The package is fetched from npm at startup.
Ask the agent to run ddsetup. The plugin walks through site selection.
Restart OpenCode again to activate the MCP Server, and complete the OAuth login flow when prompted.
Verify that you have the required permissions for the Datadog resources you want to access.
To enable product-specific tools, ask the agent to run ddtoolsets.

After setup, ask the agent to run ddconfig to change your Datadog site or troubleshoot the connection.

Manual configuration

To configure the MCP Server without the plugin, add the following to your opencode.json configuration file.

Selected endpoint (): .

{
  "mcp": {
    "datadog": {
      "type": "remote",
      "url": "",
      "enabled": true
    }
  }
}

To enable product-specific tools, include the toolsets query parameter at the end of the endpoint URL. For example, this URL enables only APM and LLM Observability tools:

?toolsets=apm,llmobs

To enable all generally available toolsets, use toolsets=all. This works best for clients that support tool filtering.

Datadog’s Cursor and VS Code extension includes built-in access to the managed Datadog MCP Server. GitHub Copilot can also access the Datadog MCP Server in VS Code (requires an active GitHub Copilot subscription).

Install the extension (omit --profile and profile name to install to the default VS Code profile):
```
code --install-extension datadog.datadog-vscode --profile <PROFILE_NAME>
```
Alternatively, install the Datadog extension. If you have the extension installed already, make sure it’s the latest version.
Sign in to your Datadog account.
Restart the IDE.
Confirm the Datadog MCP Server is available and the tools are listed: Open the chat panel, select agent mode, and click the Configure Tools button.
If you previously installed the Datadog MCP Server manually, remove it from the IDE’s configuration to avoid conflicts. Open the command palette (Shift + Cmd/Ctrl + P) and run MCP: Open User Configuration.
Verify that you have the required permissions for the Datadog resources you want to access.

Warp is an agentic terminal with built-in MCP support. Point the Warp agent to the MCP Server endpoint for your regional Datadog site. For the correct instructions, use the Datadog Site selector on the right side of this documentation page to select your site.

Selected endpoint (): .

In the Warp app, go to Settings > MCP Servers and click + Add.
Paste the following configuration:
```
{
   "Datadog": {
     "url": ""
   }
 }
```
To enable product-specific tools, include the toolsets query parameter at the end of the endpoint URL. For example, this URL enables only APM and LLM Observability tools (use toolsets=all to enable all generally available toolsets, best for clients that support tool filtering):
```
?toolsets=apm,llmobs
```
Click Start on the Datadog server. Warp opens your browser to complete the OAuth login flow. Credentials are stored securely on your device and reused for future sessions.
Verify that you have the required permissions for the Datadog resources you want to access.

For most other supported clients, use these instructions for remote authentication. For Cline or when remote authentication is unreliable or not available, use local binary authentication.

Selected endpoint (): .

Add the Datadog MCP Server to your client’s configuration file using the HTTP transport and your site’s endpoint URL. For example:
```
{
   "mcpServers": {
     "datadog": {
       "type": "http",
       "url": ""
     }
   }
 }
```
To enable product-specific tools, include the toolsets query parameter at the end of the endpoint URL. For example, this URL enables only APM and LLM Observability tools (use toolsets=all to enable all generally available toolsets, best for clients that support tool filtering):
```
?toolsets=apm,llmobs
```
Verify that you have the required permissions for the Datadog resources you want to access.

Toolsets

The Datadog MCP Server supports toolsets, which allow you to use only the MCP tools you need, saving valuable context window space. To use a toolset, include the toolsets query parameter in the endpoint URL when connecting to the MCP Server (remote authentication only). Use toolsets=all to enable all generally available toolsets at once.

For example, based on your selected Datadog site ():

Retrieve only the core tools (this is the default if toolsets is not specified):
Retrieve only Synthetic Testing-related tools:
```
?toolsets=synthetics
```
Retrieve core, Synthetic Testing, and Software Delivery tools:
```
?toolsets=core,synthetics,software-delivery
```
Retrieve all generally available tools:
```
?toolsets=all
```

Enabling all toolsets increases the number of tool definitions sent to your AI client, which consumes context window space. toolsets=all works best with clients that support tool filtering, such as Claude Code.

Available toolsets

These toolsets are generally available. See Datadog MCP Server Tools for a complete reference of available tools organized by toolset, with example prompts.

core: The default toolset for logs, metrics, traces, dashboards, monitors, incidents, hosts, services, events, and notebooks
alerting: Tools for validating and creating monitors, searching monitor groups, retrieving monitor templates, analyzing monitor coverage, and searching SLOs
cases: Tools for Case Management, including creating, searching, and updating cases; managing projects; and linking Jira issues
dashboards: Tools for retrieving, creating, updating, and deleting dashboards, plus widget schema reference and validation
dbm: Tools for interacting with Database Monitoring
ddsql: Tools for querying Datadog data using DDSQL, a SQL dialect with support for infrastructure resources, logs, metrics, RUM, spans, and other Datadog data sources
error-tracking: Tools for interacting with Datadog Error Tracking
feature-flags: Tools for managing feature flags, including creating, listing, and updating flags and their environments
kubernetes: Tools for searching and describing Kubernetes resources and retrieving manifests across all clusters
llmobs: Tools for searching and analyzing LLM Observability spans and experiments
networks: Tools for Cloud Network Monitoring analysis and Network Device Monitoring
onboarding: Agentic onboarding tools for guided Datadog setup and configuration
product-analytics: Tools for interacting with Product Analytics queries
reference-tables: Tools for managing Reference Tables, including listing tables, reading rows, appending rows, and creating tables from cloud storage
security: Tools for code security scanning and searching security signals and security findings
software-delivery: Tools for interacting with Software Delivery (CI Visibility and Test Optimization)
synthetics: Tools for interacting with Datadog Synthetic tests
widgets: Tools for dashboard and notebook widget visualization, validation, and type conversion.
workflows: Tools for Workflow Automation, including listing, inspecting, executing, and configuring workflows for agent use

Preview toolsets

These toolsets are in Preview. Sign up for a toolset by completing the Product Preview form or contact Datadog support to request access.

apm: (Sign up) Tools for in-depth APM trace analysis, span search, Watchdog insights, and performance investigation
code-exec: A single tool that runs agent-authored TypeScript in a Datadog-managed sandbox with direct access to Datadog APIs, for multi-signal investigation and ad-hoc data exploration in one call
rum: Tools for Real User Monitoring, including summarizing application performance, inspecting application configuration, and running performance investigations

Supported clients

Client	Developer	Notes
Cursor	Cursor	Datadog Cursor & VS Code extension recommended.
Claude Code	Anthropic	Datadog Claude Code plugin recommended.
Claude	Anthropic	Datadog Claude Connector recommended. Includes Claude Cowork.
Codex CLI	OpenAI
Gemini CLI	Google
Warp	Warp
VS Code	Microsoft	Datadog Cursor & VS Code extension recommended.
JetBrains IDEs	JetBrains	Datadog plugin recommended.
Kiro, Kiro CLI	Amazon Web Services
Goose	Agentic AI Foundation
OpenCode	SST	Datadog OpenCode plugin recommended.
Cline	Various	See the Other tab above. Use local binary authentication for Cline if remote authentication is unreliable.

The Datadog MCP Server is under significant development, and additional supported clients may become available.

Required permissions

MCP Server tools require the following Datadog user role permissions:

Permission	Required for
`mcp_read`	Tools that read data from Datadog (for example, querying monitors, searching logs, retrieving dashboards)
`mcp_write`	Tools that create or modify resources in Datadog (for example, creating monitors, muting hosts)

In addition to mcp_read or mcp_write, users need the standard Datadog permissions for the underlying resource. For example, using an MCP tool that reads monitors requires both mcp_read and the Monitors Read permission. See Datadog Role Permissions for the full list of resource-level permissions.

Users with the Datadog Standard Role have both MCP Server permissions by default. If your organization uses custom roles, add the permissions manually:

Go to Organization Settings > Roles as an administrator, and click the role you want to update.
Click Edit Role (pencil icon).
Under the permissions list, select the MCP Read and MCP Write checkboxes.
Select any other resource-level permissions you need for the role.
Click Save.

Organization administrators can manage global MCP access and write capabilities from Organization Settings.

Authentication

The MCP Server uses OAuth 2.0 for authentication. If you cannot go through the OAuth flow (for example, on a server), you can provide a Datadog API key and application key as DD_API_KEY and DD_APPLICATION_KEY HTTP headers.

For example, based on your selected Datadog site ():

{
  "mcpServers": {
    "datadog": {
      "type": "http",
      "url": "",
      "headers": {
          "DD_API_KEY": "<YOUR_API_KEY>",
          "DD_APPLICATION_KEY": "<YOUR_APPLICATION_KEY>"
      }
    }
  }
}

For security, use a scoped API key and application key from a service account that has only the required permissions.

Local binary authentication

Local authentication is recommended for Cline and when remote authentication is unreliable or not available. After installation, you typically do not need to update the local binary to benefit from MCP Server updates, as the tools are remote.

Set up Datadog MCP Server local binary

Install the Datadog MCP Server binary (macOS and Linux):
```
curl -sSL https://coterm.datadoghq.com/mcp-cli/install.sh | bash
```
This installs the binary to ~/.local/bin/datadog_mcp_cli.
For Windows, download the Windows version.
Run datadog_mcp_cli login manually to walk through the OAuth login flow and choose a Datadog site.
Configure your AI client to use the stdio transport with datadog_mcp_cli as the command. For example, in macOS (replace <USERNAME> with your OS username):
```
{
  "mcpServers": {
    "datadog": {
      "type": "stdio",
      "command": "/Users/<USERNAME>/.local/bin/datadog_mcp_cli",
      "args": [],
      "env": {}
    }
  }
}
```
For other operating systems, replace the command path with the location of the downloaded binary:
- Linux: /home/<USERNAME>/.local/bin/datadog_mcp_cli
- Windows: <USERNAME>\bin\datadog_mcp_cli.exe
For Claude Code, you can instead run:
```
claude mcp add datadog --scope user -- ~/.local/bin/datadog_mcp_cli
```
Fully restart your AI client to apply the configuration and load the MCP Server.

Test access to the MCP Server

Install the MCP inspector, a developer tool for testing and debugging MCP servers.
```
npx @modelcontextprotocol/inspector
```
In the inspector’s web UI, for Transport Type, select Streamable HTTP.
For URL, enter the MCP Server endpoint for your regional Datadog site.
For example, for :
Click Connect, then go to Tools > List Tools.
Check if the available tools appear.