Datadog API

Overview

The Datadog API enables developers and operations teams to programmatically interact with the Datadog observability platform, facilitating comprehensive monitoring and analysis of cloud-native applications and infrastructure. Datadog provides a unified view across various telemetry types, including metrics, logs, traces, and security events, making it suitable for organizations requiring full-stack visibility. The API extends this capability by allowing users to automate data ingestion, configuration management, and data retrieval tasks.

Datadog is designed for technical buyers and developers managing complex, distributed systems, particularly those deployed in cloud environments. It excels in scenarios where organizations need to correlate data from diverse sources, such as AWS, Google Cloud, and Azure, alongside on-premises infrastructure. Its application performance monitoring (APM) capabilities are utilized by software development teams to trace requests across microservices, identify bottlenecks, and optimize application performance. The platform's log management features centralize logs from all services, enabling efficient searching, filtering, and analysis for debugging and operational insights.

Beyond traditional monitoring, Datadog also provides security monitoring features, allowing teams to detect threats, investigate security incidents, and maintain compliance. The API integrates with existing CI/CD pipelines to embed observability practices into the software delivery lifecycle, enabling automated deployment of monitoring configurations and real-time feedback on application health. Datadog's extensive client libraries (SDKs) for languages like Python, Go, and Node.js simplify API consumption, providing idiomatic interfaces for common tasks. According to a 2023 report referenced by Forrester, organizations are increasingly adopting observability platforms to improve operational efficiency and accelerate incident resolution, underscoring the demand for integrated solutions like Datadog's. Forrester's analysis of Datadog's economic impact highlights benefits such as reduced unplanned downtime and improved developer productivity, often facilitated by API-driven automation.

The platform shines in environments characterized by rapid change, such as those adopting serverless architectures or Kubernetes, where dynamic infrastructure demands real-time, granular monitoring. Its synthetic monitoring and real user monitoring (RUM) products extend observability to the end-user experience, providing insights into website and application performance from a user's perspective. The API is central to customizing these capabilities, allowing users to create custom dashboards, define alerts, and integrate monitoring data with other operational tools.

Key features

• Infrastructure Monitoring: Collects metrics from servers, containers, and cloud services for real-time visibility into resource utilization and health.
• Log Management: Aggregates, processes, and analyzes logs from all sources, enabling search, filtering, and alerting on log data.
• Application Performance Monitoring (APM): Traces requests across distributed services, identifies performance bottlenecks, and visualizes service dependencies.
• Security Monitoring: Detects threats and suspicious activities across infrastructure and applications, aiding in security incident response.
• Real User Monitoring (RUM): Gathers and analyzes data on actual user interactions with web and mobile applications to assess front-end performance.
• Synthetic Monitoring: Simulates user journeys and API requests to proactively identify performance and availability issues.
• Dashboards and Visualizations: Provides customizable dashboards to visualize metrics, logs, and traces, supporting real-time operational insights.
• Alerting and Anomaly Detection: Configures alerts based on thresholds, anomalies, and forecasts, integrating with communication tools.
• Extensive Integrations: Connects with over 600 technologies, including cloud providers, databases, web servers, and message queues.

Pricing

Datadog employs a usage-based pricing model, with costs varying per product and usage tier. Specific pricing details are available on their official pricing page. The table below provides a summary of starting points for key products as of May 2026.

For detailed and up-to-date pricing information, including various tiers and add-ons, refer to the Datadog pricing page.

Common integrations

• Cloud Platforms: AWS, Google Cloud, Azure for collecting metrics, logs, and traces from cloud services. The Datadog AWS integration documentation provides setup instructions.
• Container Orchestration: Kubernetes, Docker for monitoring container health, performance, and resource usage.
• Databases: MySQL, PostgreSQL, MongoDB, Elasticsearch for database performance monitoring.
• Web Servers: Nginx, Apache HTTP Server for monitoring web traffic and server health.
• Message Queues: Kafka, RabbitMQ for monitoring message broker performance and message throughput.
• CI/CD Tools: Jenkins, GitLab CI/CD, GitHub Actions for integrating observability into automated deployment pipelines.
• Incident Management: PagerDuty, Opsgenie for alerting and incident response workflows.

Alternatives

• New Relic: Offers a similar suite of observability products, including APM, infrastructure monitoring, and logging.
• Grafana Labs: Provides open-source and commercial solutions for visualization, monitoring, and observability, often used with Prometheus and Loki.
• Splunk: Known for its data platform for security, observability, and operational intelligence, with strong log management capabilities.
• AWS CloudWatch: Amazon's native monitoring service for AWS resources and applications, offering metrics, logs, and events.
• Azure Monitor: Microsoft's integrated monitoring solution for Azure resources and on-premises environments.

Getting started

To begin sending custom metrics to Datadog using the Python SDK, you first need to install the datadog library and configure your API and Application keys. These keys are obtained from your Datadog account settings. The following example demonstrates how to initialize the API client and send a simple counter metric.

from datadog import initialize, api
import os
import time

# Configure Datadog API keys
# It's recommended to use environment variables for keys in production
options = {
    'api_key': os.getenv('DATADOG_API_KEY', 'YOUR_DATADOG_API_KEY'),
    'application_key': os.getenv('DATADOG_APP_KEY', 'YOUR_DATADOG_APP_KEY')
}

initialize(**options)

# Define a custom metric name and tags
metric_name = 'my_application.processed_requests'
tags = ['env:dev', 'service:api-gateway']

print(f"Sending metric '{metric_name}' with tags {tags}...")

# Send a counter metric. This example sends a value of 1 each time.
# In a real application, this would be incremented based on events.
result = api.Metric.send(
    metric=metric_name,
    points=[(int(time.time()), 1)], # Current timestamp and metric value
    type='count', # 'count', 'gauge', or 'rate'
    tags=tags
)

if result['status'] == 'ok':
    print(f"Metric sent successfully: {result}")
else:
    print(f"Failed to send metric: {result}")

# Example of sending a gauge metric (e.g., current temperature)
print(f"Sending gauge metric 'my_application.temperature'...")
api.Metric.send(
    metric='my_application.temperature',
    points=[(int(time.time()), 25.5)], # Current timestamp and value
    type='gauge',
    tags=['location:datacenter-1']
)
print("Gauge metric sent.")

Before running this code, ensure you have the datadog library installed (pip install datadog) and replace 'YOUR_DATADOG_API_KEY' and 'YOUR_DATADOG_APP_KEY' with your actual keys, or set them as environment variables DATADOG_API_KEY and DATADOG_APP_KEY. After execution, you can view the sent metrics in your Datadog dashboard under the Metrics Explorer. For more detailed API interactions, consult the Datadog API reference documentation.