SEO Title: How to Install Datadog CLI on Mac, Windows & Linux – Complete 2026 Tutorial

Meta Description: Learn how to install Datadog Pup CLI and Datadog CI CLI on macOS, Windows, Ubuntu, Debian, RHEL, and CentOS. Includes installation commands, authentication, verification, troubleshooting, and updates.

Focus Keywords: install Datadog CLI, Datadog CLI macOS, Datadog CLI Windows, Datadog CLI Linux, Datadog Pup CLI, Datadog CI CLI, datadog-ci install, Datadog Homebrew, Datadog CLI Ubuntu

---

1. Introduction

Datadog is a cloud-based observability and monitoring platform that helps organizations monitor applications, infrastructure, logs, metrics, traces, security events, and cloud services.

Although Datadog provides a comprehensive web interface, developers, DevOps engineers, SREs, and platform engineers often need command-line tools to manage monitoring resources and automate operations.

Datadog provides CLI tools for these tasks.

In this tutorial, we will learn how to install and configure Datadog command-line tools across macOS, Windows, and Linux.

We will cover:

• Installing Datadog Pup CLI on Intel and Apple Silicon Macs.
• Installing Datadog CLI on Windows using PowerShell.
• Installing Datadog CLI on Ubuntu and Debian.
• Installing Datadog CLI on RHEL, CentOS, and Amazon Linux.
• Installing the Datadog CI CLI using npm.
• Authenticating with Datadog using OAuth2 or API keys.
• Managing monitors, logs, metrics, dashboards, and SLOs.
• Updating and uninstalling Datadog CLI.
• Troubleshooting installation and authentication problems.

2. Understanding Datadog’s Different CLI Tools

Unlike GitHub, which provides a general-purpose executable named gh, Datadog has several command-line tools designed for different purposes.

Tool	Executable	Primary purpose
Datadog Pup CLI	pup	General-purpose Datadog API and resource management
Datadog CI CLI	datadog-ci	CI/CD automation and Continuous Testing
Datadog Agent CLI	datadog-agent	Local monitoring Agent administration
Datadog Sync CLI	datadog-sync	Synchronize supported resources between organizations

Which Datadog CLI Should You Install?

If you want to work with monitors, dashboards, logs, metrics, SLOs, or other Datadog platform resources, use Datadog Pup CLI.

If you need to integrate Datadog with GitHub Actions, GitLab CI, Jenkins, Azure DevOps, or other CI/CD systems, use Datadog CI CLI.

If you need to inspect or troubleshoot a locally installed Datadog monitoring Agent, use Datadog Agent CLI.

This guide focuses on Pup CLI for general platform administration and also explains how to install datadog-ci for automation.

---

Part 1: Installing Datadog Pup CLI

3. What Is Datadog Pup CLI?

Pup is Datadog’s general-purpose, API-oriented command-line interface.

It provides commands for interacting with major Datadog products directly from a terminal.

Pup supports functionality across areas such as:

• Infrastructure monitoring
• Metrics
• Logs
• APM and traces
• Monitors and alerts
• Dashboards
• Service Level Objectives (SLOs)
• Incident management
• Real User Monitoring (RUM)
• Security monitoring
• Datadog API resources

Pup is also designed to support automation and AI-agent workflows.

The executable is:

pup

Example commands:

pup --help
pup auth login
pup auth status
pup monitors list
pup dashboards list
pup slos listCode language: PHP (php)

Pup provides structured output, allowing results to be processed by scripts and automation tools.

4. Prerequisites

Before installation, check the following requirements.

Requirement	Details
Operating system	macOS, Windows, or supported Linux
Processor	Compatible x86-64 or ARM64
Internet	Required for installation and Datadog APIs
Terminal	Terminal, Zsh, Bash, or PowerShell
Datadog account	Required for authenticated platform operations
Permissions	Permission to install software
Homebrew	Recommended for macOS; optional on Linux

You can access Datadog from:

https://www.datadoghq.com

Official CLI documentation:

https://docs.datadoghq.com/cli

Official GitHub repository:

https://github.com/DataDog/pup

---

5. How to Install Datadog CLI on macOS

The recommended method for installing Pup CLI on macOS is Homebrew.

This installation method works on both Intel-based and Apple Silicon Macs.

Step 1: Open Terminal

Open Terminal from:

Applications → Utilities → Terminal

Alternatively, use Spotlight Search.

Step 2: Check the macOS Version

Execute:

sw_vers

Check the processor architecture:

uname -m

For Apple Silicon:

arm64

For Intel Macs:

x86_64

Both architectures have official Pup CLI builds.

Step 3: Check Whether Homebrew Is Installed

Execute:

brew --version

If Homebrew is installed, its version will be displayed.

If you encounter:

zsh: command not found: brewCode language: HTTP (http)

Install Homebrew using its official installation script:

/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"Code language: JavaScript (javascript)

Review the installer before executing it and follow the setup instructions provided.

Verify:

brew --version

Step 4: Update Homebrew

Execute:

brew update

This refreshes Homebrew’s package metadata.

Step 5: Add the Datadog Homebrew Tap

Execute:

brew tap datadog-labs/pack

This configures the Homebrew tap containing Pup CLI.

Step 6: Install Datadog Pup CLI

Execute:

brew install datadog-labs/pack/pup

Homebrew downloads and installs the Pup CLI.

Step 7: Verify Installation

Run:

pup --version

The command should display the installed Pup version.

Check the available commands:

pup --help

Find the executable:

which pup

Or:

command -v pup

On an Apple Silicon Mac, the command path may be under:

/opt/homebrew/bin/

On an Intel Mac, it may be under:

/usr/local/bin/

Step 8: Confirm the Homebrew Installation

Run:

brew list --versions pupCode language: PHP (php)

Display package details:

brew info pup

Datadog Pup CLI is now installed on macOS.

Alternative: Install Pup CLI on macOS Without Homebrew

Datadog also provides a script-based installation method.

Download the installation script:

curl -fsSLo pup-install.sh \
  https://raw.githubusercontent.com/DataDog/pup/main/install.shCode language: JavaScript (javascript)

Review its contents:

less pup-install.shCode language: CSS (css)

Run the script:

sh pup-install.shCode language: CSS (css)

On macOS without Homebrew, the installer downloads the appropriate binary and normally installs it in:

~/.local/binCode language: JavaScript (javascript)

Ensure that this directory is on your PATH.

For example, for Zsh:

echo 'export PATH="$HOME/.local/bin:$PATH"' >> ~/.zshrc
source ~/.zshrcCode language: PHP (php)

Verify:

pup --version

For most macOS users, Homebrew is the easier installation and upgrade method.

---

6. How to Install Datadog CLI on Windows 10/11

Datadog provides prebuilt Pup CLI binaries for 64-bit Windows.

You can install Pup using PowerShell without installing Node.js, Python, or Rust.

Step 1: Open PowerShell

Open Windows PowerShell or PowerShell 7.

Step 2: Check Windows Architecture

Execute:

[System.Runtime.InteropServices.RuntimeInformation]::OSArchitectureCode language: CSS (css)

For a compatible x64 system, the result should be:

X64

Step 3: Download the Pup CLI Package

Visit the official releases page:

https://github.com/DataDog/pup/releases/latest

Download the Windows x86-64 ZIP package.

For example, Pup v2.0.0 uses:

pup_2.0.0_Windows_x86_64.zipCode language: CSS (css)

Alternatively, download that release using PowerShell:

$version = "2.0.0"

$url = "https://github.com/DataDog/pup/releases/download/v$version/pup_${version}_Windows_x86_64.zip"

$zipFile = Join-Path $HOME "Downloads\pup.zip"

Invoke-WebRequest -Uri $url -OutFile $zipFileCode language: PHP (php)

The example pins version 2.0.0 for reproducibility. To install a newer release, update the version variable after checking the official release assets.

Step 4: Create an Installation Directory

Run:

$installDir = Join-Path $HOME "Tools\PupCLI"

New-Item -ItemType Directory -Path $installDir -ForceCode language: PHP (php)

This creates a dedicated installation directory in your user profile.

Step 5: Extract the ZIP File

Execute:

Expand-Archive `
  -Path $zipFile `
  -DestinationPath $installDir `
  -ForceCode language: PHP (php)

Step 6: Locate the Pup Executable

Run:

Get-ChildItem -Path $installDir -Recurse -Filter pup.exeCode language: PHP (php)

If the executable is inside a nested directory, copy it into the installation directory:

$pupExe = Get-ChildItem -Path $installDir -Recurse -Filter pup.exe |
    Select-Object -First 1

if (-not $pupExe) {
    throw "pup.exe was not found in the downloaded package."
}

if ($pupExe.DirectoryName -ne $installDir) {
    Copy-Item $pupExe.FullName (Join-Path $installDir "pup.exe") -Force
}Code language: PHP (php)

Step 7: Verify the Executable

Run:

& "$installDir\pup.exe" --versionCode language: JavaScript (javascript)

If the version is displayed, the executable is working.

Step 8: Add Pup CLI to Windows PATH

Execute:

$userPath = [Environment]::GetEnvironmentVariable("Path", "User")

if (($userPath -split ";") -notcontains $installDir) {
    $newPath = ($userPath.TrimEnd(";") + ";" + $installDir).TrimStart(";")

    [Environment]::SetEnvironmentVariable(
        "Path",
        $newPath,
        "User"
    )
}Code language: PHP (php)

Update the current PowerShell session:

$env:Path += ";$installDir"Code language: PHP (php)

Step 9: Verify Installation Globally

Run:

pup --version

Display help:

pup --help

Find the executable:

Get-Command pup

Or:

where.exe pupCode language: CSS (css)

If the executable is not found after changing PATH, open a new PowerShell window.

Datadog Pup CLI is now installed on Windows.

Alternative: Install Pup from Git Bash

If Git Bash, MSYS2, or Cygwin is installed, you can use Datadog’s installer script:

curl -fsSL https://raw.githubusercontent.com/DataDog/pup/main/install.sh | shCode language: JavaScript (javascript)

The installer downloads the appropriate release archive and verifies its SHA-256 checksum.

It normally installs the executable under the user’s ~/.local/bin directory.

Make sure that directory is in your shell PATH.

---

7. How to Install Datadog CLI on Ubuntu and Debian

For Ubuntu and Debian Linux, the Datadog-provided installation script is a convenient approach.

The same method also works on several other supported Linux distributions.

Step 1: Check Linux Distribution

Execute:

cat /etc/os-release

Check your architecture:

uname -m

Possible results:

x86_64

Or:

aarch64

Pup has prebuilt Linux x86-64 and ARM64 release binaries.

Step 2: Update Linux Packages

For Ubuntu or Debian:

sudo apt update

Step 3: Install Required Utilities

Execute:

sudo apt install -y curl ca-certificates tar

Step 4: Download the Official Installation Script

Run:

curl -fsSLo pup-install.sh \
  https://raw.githubusercontent.com/DataDog/pup/main/install.shCode language: JavaScript (javascript)

Review the downloaded script:

less pup-install.shCode language: CSS (css)

This is recommended before executing scripts retrieved from the internet.

Step 5: Install Datadog Pup CLI

Execute:

sh pup-install.shCode language: CSS (css)

The installer determines the operating system and architecture, downloads the corresponding binary, and verifies its checksum.

By default, non-Homebrew installations use:

~/.local/binCode language: JavaScript (javascript)

Step 6: Add the Installation Directory to PATH

Check whether the directory is already included:

echo "$PATH"Code language: PHP (php)

If necessary, add it for Bash:

echo 'export PATH="$HOME/.local/bin:$PATH"' >> ~/.bashrcCode language: PHP (php)

Reload:

source ~/.bashrc

If you use Zsh, update ~/.zshrc instead.

Step 7: Verify Installation

Run:

pup --version

And:

pup --help

Find the executable:

command -v pup

The installation is complete.

---

8. How to Install Datadog CLI on RHEL, CentOS, Rocky Linux, and Amazon Linux

Pup’s official installation script can also install the CLI on compatible RPM-based Linux distributions.

Unlike the Datadog monitoring Agent, Pup does not require setting up a Datadog Agent YUM or DNF repository.

Step 1: Check the Operating System

cat /etc/os-release

Check architecture:

uname -m

Step 2: Install Required Utilities

On a DNF-based distribution:

sudo dnf install -y curl tar gzip ca-certificates

On older systems using YUM:

sudo yum install -y curl tar gzip ca-certificates

Step 3: Download and Review the Installer

curl -fsSLo pup-install.sh \
  https://raw.githubusercontent.com/DataDog/pup/main/install.shCode language: JavaScript (javascript)

Review:

less pup-install.shCode language: CSS (css)

Step 4: Install Pup CLI

sh pup-install.shCode language: CSS (css)

Step 5: Configure PATH

For Bash:

echo 'export PATH="$HOME/.local/bin:$PATH"' >> ~/.bashrc
source ~/.bashrcCode language: PHP (php)

Step 6: Verify Installation

pup --version

pup --help

command -v pup

Pup CLI is now available on your Linux workstation or server.

---

9. Alternative Linux Installation Using a Standalone Binary

You can install Pup manually without running the installation script.

The following example uses the official Linux x86-64 v2.0.0 release archive.

Step 1: Download the Release

curl -fL \
  https://github.com/DataDog/pup/releases/download/v2.0.0/pup_2.0.0_Linux_x86_64.tar.gz \
  -o pup.tar.gzCode language: JavaScript (javascript)

For ARM64, use:

curl -fL \
  https://github.com/DataDog/pup/releases/download/v2.0.0/pup_2.0.0_Linux_arm64.tar.gz \
  -o pup.tar.gzCode language: JavaScript (javascript)

Download only the archive matching your system architecture.

Step 2: Verify the Download

Download the published checksum file for the same release:

curl -fL \
  https://github.com/DataDog/pup/releases/download/v2.0.0/pup_2.0.0_checksums.txt \
  -o pup_2.0.0_checksums.txtCode language: JavaScript (javascript)

Check the downloaded archive’s hash:

sha256sum pup.tar.gzCode language: CSS (css)

Compare the hash against the official checksum for the corresponding release asset.

The filename in the checksum manifest refers to the original release archive name, so be sure to match the correct entry rather than just the locally renamed file.

For stronger supply-chain validation, Datadog also publishes signed checksum metadata that can be verified using Sigstore/cosign.

Step 3: Extract the Archive

tar -xzf pup.tar.gzCode language: CSS (css)

Step 4: Find the Executable

find . -type f -name pup

Locate the extracted executable.

Step 5: Install the Executable

If it was extracted in the current directory:

sudo install -m 0755 ./pup /usr/local/bin/pup

If it was extracted in a subdirectory, adjust the source path.

Step 6: Verify

pup --version

pup --help

The standalone binary approach is useful for controlled servers and reproducible installation workflows.

---

10. How to Authenticate Datadog Pup CLI

After installing Pup CLI, authenticate with your Datadog organization.

Pup supports OAuth2 authentication and API key authentication.

Method 1: OAuth2 Browser Login (Recommended)

Step 1: Configure the Datadog Site

Datadog operates regional sites.

Examples include:

Region	Datadog site
US1	datadoghq.com
US3	us3.datadoghq.com
US5	us5.datadoghq.com
EU	datadoghq.eu
AP1	ap1.datadoghq.com
AP2	ap2.datadoghq.com

Select the site corresponding to your Datadog organization.

On macOS or Linux:

export DD_SITE="datadoghq.com"Code language: JavaScript (javascript)

On Windows PowerShell:

$env:DD_SITE = "datadoghq.com"Code language: PHP (php)

Step 2: Log In

Execute:

pup auth login

The CLI initiates a browser-based OAuth2 authentication workflow.

Follow the prompts to complete authentication with your Datadog account.

OAuth2 uses scoped access rather than requiring you to manually supply long-lived application credentials.

Note: OAuth2 login requires the relevant functionality, including Dynamic Client Registration, to be available for your Datadog site. If it is unavailable, use API key authentication.

Step 3: Verify Authentication Status

Run:

pup auth status

Step 4: Test Connectivity

Execute:

pup auth test

This checks the connection using your configured authentication.

Step 5: List Datadog Monitors

Run:

pup monitors listCode language: PHP (php)

If the account has appropriate permissions, the CLI retrieves the organization’s accessible monitors.

Step 6: Log Out

When required:

pup auth logout

Method 2: Authenticate Using API and Application Keys

For unattended automation, Pup also supports Datadog API and application keys.

Configure credentials in your Datadog organization.

Use appropriately scoped permissions.

macOS/Linux

Environment variable names for Pup are:

DD_API_KEY
DD_APP_KEY
DD_SITE

Supply these securely through your terminal session, approved secret manager, or CI/CD secret configuration.

For example, in a trusted interactive terminal:

read -r -s -p "Datadog API key: " DD_API_KEY
echo
read -r -s -p "Datadog application key: " DD_APP_KEY
echo

export DD_API_KEY DD_APP_KEY
export DD_SITE="datadoghq.com"Code language: JavaScript (javascript)

This avoids placing literal secret values in the command history.

Windows PowerShell

Read the keys interactively:

$apiKey = Read-Host "Datadog API key" -AsSecureString
$appKey = Read-Host "Datadog application key" -AsSecureStringCode language: PHP (php)

Convert the entered values into environment variables for the current process:

$env:DD_API_KEY = [System.Net.NetworkCredential]::new("", $apiKey).Password
$env:DD_APP_KEY = [System.Net.NetworkCredential]::new("", $appKey).Password
$env:DD_SITE = "datadoghq.com"Code language: PHP (php)

These environment variables contain the key values as plaintext in process memory. Avoid displaying them, logging them, or persisting them insecurely.

Test API Key Authentication

Run:

pup monitors listCode language: PHP (php)

Pup uses its configured authentication automatically.

If an existing OAuth session is active, it takes precedence over API key credentials unless authentication selection is changed.

---

11. Essential Datadog Pup CLI Commands

After installation and authentication, you can perform many read-only Datadog operations.

Check Version

pup --version

Display Help

pup --help

Check Authentication

pup auth status

Test Connection

pup auth test

List Monitors

pup monitors listCode language: PHP (php)

Filter Monitors by Tag

pup monitors list --tags="team:platform"Code language: PHP (php)

List Dashboards

pup dashboards listCode language: PHP (php)

Retrieve a Dashboard

pup dashboards get DASHBOARD_IDCode language: JavaScript (javascript)

Replace DASHBOARD_ID with an existing dashboard identifier.

List SLOs

pup slos listCode language: PHP (php)

Retrieve an SLO

pup slos get SLO_IDCode language: JavaScript (javascript)

Search Recent Error Logs

pup logs search --query="status:error" --from="1h"Code language: JavaScript (javascript)

This searches logs with error status over the previous hour.

Results depend on your permissions, indexes, and retained data.

Query CPU Metrics

pup metrics query --query="avg:system.cpu.user{*}" --from="1h"Code language: JavaScript (javascript)

Search for Metrics

pup metrics list --filter="system.*"Code language: PHP (php)

List Incidents

pup incidents listCode language: PHP (php)

Use the command-specific help for supported filtering options:

pup monitors --help
pup logs --help
pup metrics --help

Pup can also create, update, and delete supported resources. Confirm the target organization, permissions, and command behavior before executing write operations.

---

Part 2: Installing Datadog CI CLI

12. What Is Datadog CI CLI?

Datadog CI CLI is a separate command-line tool designed for CI/CD integrations.

Its executable is:

datadog-ci

It can support workflows such as:

• Running Datadog Synthetic tests from CI/CD.
• Uploading JavaScript source maps.
• Sending supported CI events and metadata.
• Tracing custom CI pipeline commands.
• Automating Datadog-related development workflows.

The npm package is:

@datadog/datadog-ciCode language: CSS (css)

Official repository:

https://github.com/DataDog/datadog-ci

13. Install Datadog CI CLI on macOS

Step 1: Check Node.js

Execute:

node --version

Check npm:

npm --version

If Node.js is unavailable and you use Homebrew:

brew install node

For CI/CD environments, choose an actively supported Node.js LTS release compatible with your selected datadog-ci version.

Step 2: Install Datadog CI CLI Globally

Execute:

npm install -g @datadog/datadog-ciCode language: CSS (css)

Step 3: Verify Installation

Run:

datadog-ci version

Display help:

datadog-ci --help

Locate the executable:

command -v datadog-ci

Step 4: Inspect Available Plugins

datadog-ci plugin listCode language: PHP (php)

For example, install the Synthetic testing plugin:

datadog-ci plugin install synthetics

Datadog CI CLI is now installed on macOS.

---

14. Install Datadog CI CLI on Windows

Step 1: Open PowerShell

Open PowerShell or Windows Terminal.

Step 2: Install Node.js

Check:

node --version

If Node.js is not installed, you can install Node.js LTS through WinGet:

winget install OpenJS.NodeJS.LTSCode language: CSS (css)

After installation, open a new PowerShell window.

Verify:

node --version
npm --version

Step 3: Install Datadog CI CLI

Execute:

npm install -g @datadog/datadog-ciCode language: CSS (css)

Step 4: Verify

Run:

datadog-ci version

Display help:

datadog-ci --help

Find the executable:

Get-Command datadog-ci

Step 5: Install a Plugin

For Synthetic testing:

datadog-ci plugin install synthetics

The installation is complete.

---

15. Install Datadog CI CLI on Ubuntu/Debian Linux

Step 1: Update Packages

sudo apt update

Step 2: Check Whether Node.js and npm Are Installed

node --version
npm --version

If both are already present and meet the CLI’s requirements, continue to Step 4.

Otherwise, install a supported Node.js LTS release using an approved Node.js distribution or version manager.

For a basic distribution-provided installation:

sudo apt install -y nodejs npm

Important: The Ubuntu/Debian repositories may provide older Node.js versions. Check compatibility with the selected Datadog CI CLI version rather than assuming every packaged Node.js version is supported.

Step 3: Verify Node.js

node --version
npm --version

Step 4: Install Datadog CI CLI

npm install -g @datadog/datadog-ciCode language: CSS (css)

If a permission error occurs, prefer a user-managed Node.js installation or an npm prefix configured for your user instead of automatically rerunning npm with sudo.

Step 5: Verify Installation

datadog-ci version

datadog-ci --help

Step 6: Install Synthetic Testing Plugin

datadog-ci plugin install synthetics

Datadog CI CLI is now available on Ubuntu or Debian.

---

16. Install Datadog CI CLI on RHEL, CentOS, and Amazon Linux

The CLI installation is the same once a compatible Node.js runtime and npm are available.

Step 1: Check Node.js

node --version
npm --version

Step 2: Install Node.js if Missing

On RPM-based distributions where compatible Node.js packages are available:

sudo dnf install -y nodejs npm

On older YUM-based installations:

sudo yum install -y nodejs npm

Verify the version and compatibility before continuing.

Step 3: Install Datadog CI CLI

npm install -g @datadog/datadog-ciCode language: CSS (css)

Step 4: Verify

datadog-ci version

datadog-ci --help

Step 5: Install Required Plugins

For example:

datadog-ci plugin install synthetics

For reproducible CI/CD pipelines, install an exact, tested package version rather than relying on whichever version is latest at deployment time.

---

17. Install Datadog CI CLI Without Node.js

Datadog provides standalone binaries for supported operating systems.

These binaries bundle the runtime needed to execute the CLI and include the Datadog CI plugins.

macOS — Apple Silicon

curl -fL \
  https://github.com/DataDog/datadog-ci/releases/latest/download/datadog-ci_darwin-arm64 \
  -o datadog-ci

chmod +x datadog-ci

./datadog-ci versionCode language: JavaScript (javascript)

To install system-wide after verifying the binary:

sudo install -m 0755 datadog-ci /usr/local/bin/datadog-ci

macOS — Intel

curl -fL \
  https://github.com/DataDog/datadog-ci/releases/latest/download/datadog-ci_darwin-x64 \
  -o datadog-ci

chmod +x datadog-ci

./datadog-ci versionCode language: JavaScript (javascript)

Linux — x86-64

curl -fL \
  https://github.com/DataDog/datadog-ci/releases/latest/download/datadog-ci_linux-x64 \
  -o datadog-ci

chmod +x datadog-ci

sudo install -m 0755 datadog-ci /usr/local/bin/datadog-ciCode language: JavaScript (javascript)

Verify:

datadog-ci version

Linux — ARM64

curl -fL \
  https://github.com/DataDog/datadog-ci/releases/latest/download/datadog-ci_linux-arm64 \
  -o datadog-ci

chmod +x datadog-ci

sudo install -m 0755 datadog-ci /usr/local/bin/datadog-ciCode language: JavaScript (javascript)

Windows — x64

Open PowerShell:

$installDir = Join-Path $HOME "Tools\DatadogCI"

New-Item -ItemType Directory -Force -Path $installDir

Invoke-WebRequest `
  -Uri "https://github.com/DataDog/datadog-ci/releases/latest/download/datadog-ci_win-x64" `
  -OutFile "$installDir\datadog-ci.exe"Code language: PHP (php)

Verify directly:

& "$installDir\datadog-ci.exe" versionCode language: JavaScript (javascript)

Add the directory to your Windows user PATH using the Windows Environment Variables settings or the PowerShell PATH configuration method described earlier.

When downloading standalone executables for production use, verify the release source and available artifact integrity information before executing them.

---

18. Authenticate Datadog CI CLI

Unlike Pup’s interactive OAuth2 login, datadog-ci commonly uses environment variables or configuration files for authorization.

The exact credentials required depend on the command.

For Synthetic testing, configure:

DATADOG_API_KEY
DATADOG_APP_KEY
DATADOG_SITE

These variable names differ from Pup’s DD_API_KEY and DD_APP_KEY names.

macOS/Linux

Supply the keys securely:

read -r -s -p "Datadog API key: " DATADOG_API_KEY
echo
read -r -s -p "Datadog application key: " DATADOG_APP_KEY
echo

export DATADOG_API_KEY DATADOG_APP_KEY
export DATADOG_SITE="datadoghq.com"Code language: JavaScript (javascript)

Windows PowerShell

$apiKey = Read-Host "Datadog API key" -AsSecureString
$appKey = Read-Host "Datadog application key" -AsSecureString

$env:DATADOG_API_KEY = [System.Net.NetworkCredential]::new("", $apiKey).Password
$env:DATADOG_APP_KEY = [System.Net.NetworkCredential]::new("", $appKey).Password
$env:DATADOG_SITE = "datadoghq.com"Code language: PHP (php)

For CI/CD automation, use your platform’s secret-management capabilities instead of placing credentials directly in source code.

---

19. Run Datadog Synthetic Tests from the CLI

One of the most useful features of datadog-ci is executing Datadog Synthetic tests from a command line or CI/CD pipeline.

Step 1: Install the Plugin

For an npm-installed CLI:

datadog-ci plugin install synthetics

Standalone binaries already include plugins.

Step 2: Find Your Synthetic Test Public ID

Open Datadog’s Synthetic Monitoring interface and select the test you want to execute.

Locate the test’s public ID.

Step 3: Run the Test

Execute:

datadog-ci synthetics run-tests --public-id YOUR_TEST_PUBLIC_IDCode language: PHP (php)

Replace the placeholder with the actual test public ID.

The command starts the configured Synthetic test and reports the results.

The result depends on test settings, account permissions, available test locations, and authentication.

Note: Synthetic test executions may consume billable testing resources. Only run tests you are authorized to execute.

---

20. Install Datadog CI CLI Locally in a Project

For production CI/CD pipelines, a project-local installation is often preferable to a globally installed package.

Navigate to your project directory.

If you do not already have a Node.js project:

npm init -y

Install the CLI as a development dependency:

npm install --save-dev @datadog/datadog-ciCode language: CSS (css)

Run it through npm:

npx datadog-ci version

Or, once installed:

npx datadog-ci plugin install synthetics

For automation, commit the package manifest and lockfile and use:

npm ci

This installs dependencies according to the project’s lockfile.

Datadog recommends using an exact tested version to reduce unexpected major-version changes and software supply-chain risks.

---

21. Docker Installation Alternative

If Docker is available, Datadog CI CLI can also run through its published container image.

Pull the container image:

docker pull datadog/ci

Display help:

docker run --rm datadog/ci --help

For commands requiring authentication, pass the necessary credentials through approved secrets handling.

For example, after configuring environment variables securely:

docker run --rm \
  -e DATADOG_API_KEY \
  -e DATADOG_APP_KEY \
  -e DATADOG_SITE \
  datadog/ci synthetics --help

This approach avoids installing the npm package directly on your host machine.

---

22. How to Update Datadog CLI

Updates depend on which CLI and installation method you use.

Update Pup CLI on macOS

brew update
brew upgrade datadog-labs/pack/pup

Verify:

pup --version

Update Pup CLI on Linux

For a script-managed installation, download and review the current official installer again:

curl -fsSLo pup-install.sh \
  https://raw.githubusercontent.com/DataDog/pup/main/install.shCode language: JavaScript (javascript)

After review:

sh pup-install.shCode language: CSS (css)

The installer can install the latest available release.

For version-pinned installations, specify the intended PUP_VERSION or manually replace the binary with the approved release.

Update Pup CLI on Windows

Download the newer official Windows release and replace the existing executable after validating the release artifact.

Check:

pup --version

Update Datadog CI CLI Through npm

npm install -g @datadog/datadog-ci@latestCode language: CSS (css)

Or upgrade the dependency within a project, review the changes, and update the lockfile.

Verify:

datadog-ci version

Update Standalone Datadog CI CLI

Download a newer release for the appropriate operating system and architecture, verify it, and replace the existing executable.

For CI/CD systems, prefer a tested, pinned release over unreviewed automatic upgrades.

---

23. Troubleshooting Datadog CLI Installation Errors

The following table summarizes common installation and authentication problems.

Error or symptom	Likely cause	Solution
pup: command not found	Pup missing or directory not in PATH	Verify installation directory and PATH
datadog-ci: command not found	npm executable not found in PATH	Inspect npm global prefix and shell PATH
brew: command not found	Homebrew unavailable	Install/configure Homebrew
npm: command not found	Node.js/npm missing	Install compatible Node.js
EACCES: permission denied	npm installation permission issue	Use user-managed Node.js or npm prefix
exec format error	Incorrect CPU architecture	Download the correct binary
Windows command not recognized	Executable directory missing from PATH	Correct PATH and reopen PowerShell
401 Unauthorized	Missing or invalid authentication	Check login or credentials
403 Forbidden	Insufficient permissions	Review key scopes, OAuth scopes, and roles
OAuth login fails	OAuth configuration, browser, or site issue	Verify site and use supported API-key authentication if necessary
SSL certificate error	Certificate trust or proxy issue	Check trust store and approved proxy settings
Unexpected or missing data	Wrong Datadog region or organization	Verify site, organization, and access rights

Troubleshooting 1: Pup Command Not Found

On macOS/Linux:

command -v pup

Check:

echo "$PATH"Code language: PHP (php)

If installed in the user-local directory, test:

"$HOME/.local/bin/pup" --versionCode language: JavaScript (javascript)

If this works, ensure ~/.local/bin is added to your PATH.

Troubleshooting 2: datadog-ci Command Not Found

Check npm:

npm --version

List globally installed packages:

npm list -g --depth=0Code language: PHP (php)

Inspect the global npm prefix:

npm prefix -g

Confirm that the npm global executable directory is on PATH.

For a local project installation, use:

npx datadog-ci version

Troubleshooting 3: Windows Does Not Recognize Pup

Execute:

Get-Command pup

If nothing is found, check the installation directory and PATH.

$env:PathCode language: PHP (php)

Open a new PowerShell session after correcting the environment variable.

Troubleshooting 4: OAuth Login Fails

Verify the intended Datadog site.

For example:

pup auth login --site datadoghq.euCode language: CSS (css)

Check:

pup auth status

The OAuth2 login flow requires site support for its authentication mechanisms, including Dynamic Client Registration.

If your site does not support the required OAuth2 flow, use appropriately scoped API and application keys.

Troubleshooting 5: Authentication Returns 403 Forbidden

A valid identity may still lack permission for the requested resource.

For example:

pup monitors listCode language: PHP (php)

A permission error can indicate that the identity lacks the appropriate resource access.

Check user roles, OAuth scopes, API/application key permissions, and organization selection.

Troubleshooting 6: Incorrect Datadog Region

Datadog API requests must target the correct site.

For Pup on macOS/Linux:

export DD_SITE="ap1.datadoghq.com"Code language: JavaScript (javascript)

For Datadog CI Synthetic testing:

export DATADOG_SITE="ap1.datadoghq.com"Code language: JavaScript (javascript)

Change the hostname to the actual region where your organization is hosted.

Troubleshooting 7: Linux Binary Architecture Mismatch

Check architecture:

uname -m

For x86_64, use the x86-64 Linux binary.

For aarch64, use the ARM64 binary.

Do not assume that binaries compiled for different operating systems or CPU architectures are interchangeable.

---

24. How to Uninstall Datadog CLI

Uninstall Pup CLI on macOS

If installed through Homebrew:

brew uninstall datadog-labs/pack/pup

Uninstall Pup CLI on Linux

For a user-local script installation:

rm -f "$HOME/.local/bin/pup"Code language: JavaScript (javascript)

For a manually installed system-wide binary:

sudo rm -f /usr/local/bin/pup

Remove only the executable created by the corresponding installation method.

Uninstall Pup CLI on Windows

Delete the pup.exe executable from the chosen installation directory.

Remove the directory from your Windows user PATH if it is no longer needed.

Uninstall Datadog CI CLI

For a global npm installation:

npm uninstall -g @datadog/datadog-ciCode language: CSS (css)

For a project-local dependency:

npm uninstall --save-dev @datadog/datadog-ciCode language: CSS (css)

For standalone binaries, remove the installed executable.

Important: Removing these binaries does not automatically delete all stored credentials, authentication sessions, or configuration files. Review them separately if the goal is a complete security-sensitive removal.

---

25. Datadog CLI Installation Command Cheat Sheet

Platform	Pup CLI installation	Datadog CI CLI installation
macOS Intel	brew install datadog-labs/pack/pup	npm install -g @datadog/datadog-ci
macOS Apple Silicon	Same Homebrew command	Same npm command
Windows 10/11	Official Pup Windows ZIP	npm or standalone Windows executable
Ubuntu	Official Pup installation script	npm or standalone Linux executable
Debian	Official Pup installation script	npm or standalone Linux executable
RHEL/CentOS	Official Pup installation script	npm or standalone Linux executable
Amazon Linux	Official Pup installation script	npm or standalone Linux executable
Linux with Homebrew	brew install datadog-labs/pack/pup	npm or standalone executable
Verify installation	pup --version	datadog-ci version
Display help	pup --help	datadog-ci --help
Authenticate	pup auth login	Command-specific API/application key configuration
List monitors	pup monitors list	Not the primary purpose
Run Synthetic tests	Use supported Pup Synthetic API operations	datadog-ci synthetics run-tests

---

26. Frequently Asked Questions

Q1. Does Datadog have an official CLI?

Yes. Datadog provides Pup CLI for general Datadog API operations and Datadog CI CLI for CI/CD workflows.

The Datadog Agent also includes its own administrative commands.

Q2. What is the executable name for Datadog CLI?

For general platform operations:

pup

For CI/CD operations:

datadog-ci

For local Agent administration:

datadog-agent

There is no universal requirement to install a command simply named datadog.

Q3. Can I install Datadog CLI on an Apple Silicon Mac?

Yes. Datadog provides native ARM64-compatible builds of Pup and Datadog CI CLI.

Q4. Does Datadog CLI work on Windows?

Yes. Pup and Datadog CI CLI provide Windows-compatible standalone binaries.

Q5. Do I need Node.js to install Datadog CLI?

For Pup CLI, no.

For the npm-distributed Datadog CI CLI, Node.js and npm are required.

However, Datadog CI CLI also provides standalone binaries that do not require you to install Node.js separately.

Q6. Can I use Datadog CLI without installing the Datadog Agent?

Yes.

Pup and Datadog CI CLI are independent tools.

They can communicate with Datadog services without requiring a local monitoring Agent.

Q7. Can I manage Datadog dashboards and monitors using CLI?

Yes. Pup CLI supports operations for managing monitors, dashboards, SLOs, and other platform resources.

Q8. Can I use Datadog CLI in GitHub Actions?

Yes.

Datadog CI CLI is specifically designed for CI/CD integration.

Pup can also be used in automation when appropriately authenticated.

Q9. Is Datadog CLI free?

The CLI tools are available without a separate installation charge. However, Datadog services, API-driven operations, Synthetic tests, and other monitored resources may be subject to your organization’s subscription, limits, or usage charges.

Q10. What is the difference between Datadog CLI and Datadog Agent?

The CLI communicates with Datadog APIs to perform management or automation tasks.

The Datadog Agent collects telemetry from infrastructure and applications and forwards it to Datadog.

The Agent’s own CLI is specifically for administering that installed Agent.

Q11. Should I install both Pup and datadog-ci?

Install both if you need general Datadog administration and CI/CD automation.

Otherwise, install only the tool required for your workflow.

---

27. Best Practices for Production Environments

When using Datadog CLI tools in production, follow these recommendations:

1. Download software from official Datadog repositories and trusted distribution channels.
2. Verify standalone binaries using published checksums and signatures where available.
3. Pin approved CLI versions in production automation.
4. Use OAuth2 where appropriate for interactive Pup access.
5. Use narrowly scoped machine credentials for unattended automation.
6. Store credentials in a secure secrets manager.
7. Never commit API or application keys to a Git repository.
8. Confirm the Datadog site and organization before making changes.
9. Prefer read-only access for monitoring and troubleshooting tasks.
10. Treat commands that delete, modify, or create resources as production changes requiring review.
11. Avoid mixing production and nonproduction credentials.
12. Keep CLI upgrades controlled and repeatable.
13. Use command-specific help before relying on syntax in automation.
14. Monitor API rate limits and the cost of billable operations.
15. Do not confuse Datadog Agent installation procedures with Pup or Datadog CI CLI installation.

---

28. Conclusion

Datadog provides command-line tools that help developers, DevOps engineers, and SRE teams automate observability and monitoring workflows.

For general Datadog management, Pup CLI provides access to monitors, dashboards, logs, metrics, SLOs, and many other supported resources.

For CI/CD automation, Datadog CI CLI enables Continuous Testing, Synthetic monitoring workflows, and integrations with development pipelines.

Installing these tools is straightforward:

• macOS: Use Homebrew for Pup and npm or a standalone binary for Datadog CI CLI.
• Windows: Download the official compatible executables or use npm for Datadog CI CLI.
• Ubuntu/Debian: Use Pup’s official installation script and npm or a standalone Datadog CI binary.
• RHEL/CentOS/Amazon Linux: Use the supported installation script and a compatible Node.js runtime or standalone CI binary.

Once Pup CLI is installed, begin with:

pup --version
pup auth login
pup auth status
pup monitors list
pup dashboards listCode language: PHP (php)

For Datadog CI CLI:

datadog-ci version
datadog-ci plugin list
datadog-ci plugin install syntheticsCode language: PHP (php)

With these tools configured, engineers can simplify Datadog administration, automate observability workflows, and integrate monitoring into development and deployment processes.

---

Official Documentation and References

• Datadog Pup CLI Documentation
• Datadog Pup GitHub Repository
• Datadog Pup Releases
• Datadog CI GitHub Repository
• Datadog CI Releases
• Datadog Continuous Testing Configuration
• Datadog Agent Documentation
• Datadog API and Application Keys

Last reviewed: October 20, 2026. Installation methods, supported architectures, CLI releases, and authentication requirements can change. Always consult the official documentation and verify compatibility before installing or upgrading tools in production.