# Source: https://docs.datadoghq.com/developers/integrations/check_references.md

---
title: Integration Assets Reference
description: >-
  Learn about the various assets that need to be included when preparing a
  Datadog integration.
breadcrumbs: Docs > Developers > Datadog Integrations > Integration Assets Reference
---

# Integration Assets Reference

## Overview{% #overview %}

This page walks you through the files that you need to populate in order to create an offering on the [**Integrations** page](https://app.datadoghq.com/integrations) or the [**Marketplace** page](https://app.datadoghq.com/marketplace/).

{% alert level="info" %}
Some files apply only to legacy integrations that were *not* created using the Integration Developer Platform.
{% /alert %}

## Configuration file{% #configuration-file %}

When preparing a new integration, you must include an example configuration that contains the necessary options and reasonable defaults. The example configuration fileâwhich in this case, is located at `<CHECK_NAME>/datadog_checks/<CHECK_NAME>/data/conf.yaml.example`âhas two top-level elements: `init_config` and `instances`.

The configuration under `init_config` is applied to the integration globally, and is used in every instantiation of the integration, whereas anything within `instances` is specific to a given instantiation.

Configuration blocks in either section take the following form:

```yaml
## @<COMMAND> [- <ARGS>]
## <DESCRIPTION LINE 1>
## <DESCRIPTION LINE 2>
#
<KEY>: <VALUE>
```

Configuration blocks follow a few guidelines:

- Descriptions must not be empty.
- Always follow this format: `<THIS_IS_A_PLACEHOLDER>` for placeholders. For more information, see the [Documentation Site's contributing guidelines](https://github.com/DataDog/documentation/blob/master/CONTRIBUTING.md#code-substitution).
- All required parameters are **not** commented by default.
- All optional parameters are commented by default.
- If a placeholder has a default value for an integration (like the status endpoint of an integration), it can be used instead of a generic placeholder.

### `@param` specification{% #param-specification %}

You can use the `@param` command to describe configuration blocks and provide documentation for your configuration.

`@param` is implemented using one of the following forms:

```text
@param <name> - <type> - required
@param <name> - <type> - optional
@param <name> - <type> - optional - default: <defval>
```

**Arguments**:

- `name`: The name of the parameter, such as `search_string` (mandatory).
- `type`: The data type for the parameter value (mandatory). Possible values include the following: *boolean*, *string*, *integer*, *double*, *float*, *dictionary*, *list\**, and *object\**.
- `defval`: Default value for the parameter; can be empty (optional).

`list` and `object` variables span over multiple lines and have special rules.

- In a `list`, individual elements are not documented with the `@param` specification.
- In an `object`, you can choose to either document elements individually with the `@param` specification or have a common top-level description following the specification of the object itself.

### Optional parameters{% #optional-parameters %}

An optional parameter must be commented by default. Before every line the parameter spans on, add `#` with the same indentation as the `@param` specification.

### Block comments{% #block-comments %}

You can add a block comment anywhere in the configuration file with the following rules:

- Comments start with `##`.
- Comments should be indented like any variable (the hyphen doesn't count).

For more information about YAML syntax, see the [Wikipedia article about YAML](https://en.wikipedia.org/wiki/YAML). You can also explore the [Online YAML Parser](http://yaml-online-parser.appspot.com/).

## Manifest file{% #manifest-file %}

Every offering on the [**Integrations** page](https://docs.datadoghq.com/integrations/) or the [**Marketplace** page](https://docs.datadoghq.com/developers/integrations/marketplace_offering) contains a `manifest.json` file that defines operating parameters, positioning within the greater Datadog integration ecosystem, and additional metadata.

You can find the complete list of mandatory and optional attributes for the `manifest.json` file below:

{% dl %}

{% dt %}
`manifest_version`
{% /dt %}

{% dd %}
Mandatory**Type**: String Enum.**Description**: Version of the manifest schema. Supported values include `1.0.0` and `2.0.0`.
{% /dd %}

{% dt %}
`app_uuid`
{% /dt %}

{% dd %}
Mandatory**Type**: UUID.**Description**: Globally unique UUID for this application. This is automatically generated by Datadog when the developer toolkit [`ddev create` command](https://docs.datadoghq.com/developers/integrations/create_a_tile/?tab=buildatileontheintegrationspage#populate-the-integration-tile-scaffolding) runs as part of creating tile scaffolding for your integration tile.
{% /dd %}

{% dt %}
`app_id`
{% /dt %}

{% dd %}
Mandatory**Type**: String.**Description**: The unique identifying name of this offering. Usually kebab case of the app title. For example, if the app title is "Marketplace Offering", then the `app_id` would be `marketplace-offering`.
{% /dd %}

{% dt %}
`assets`
{% /dt %}

{% dd %}
Mandatory**Type**: Dictionary.**Description**: Object containing any Datadog installable entity.
{% /dd %}

{% dt %}
`assets[dashboards]`
{% /dt %}

{% dd %}
Optional**Type**: Dictionary.**Description**: Out-of-the-box dashboards associated with this offering.
{% /dd %}

{% dt %}
`assets[dashboards["dashboard_short_name"]]`
{% /dt %}

{% dd %}
Mandatory**Type**: String.**Description**: Key and value pairs for any out-of-the-box dashboards. The key is the globally unique short name of the dashboard and the value is the relative path to the dashboard's JSON definition in relation to this manifest.
{% /dd %}

{% dt %}
`assets[integration]`
{% /dt %}

{% dd %}
Optional**Type**: Dictionary.**Description**: Object containing information about the integration.
{% /dd %}

{% dt %}
`assets[integration[auto_install]]`
{% /dt %}

{% dd %}
Mandatory**Type**: Boolean.**Description**: Whether or not the integration and related assets should be installed automatically when metrics or logs from the integration are received from the source. This is typically set to `true` for integrations using the Datadog Agent, and other integrations that are configured outside the Datadog UI. It is typically set to `false` for marketplace integrations and integrations that are configured with the Datadog UI, such as integrations using OAuth.
{% /dd %}

{% dt %}
`assets[integration[configuration]]`
{% /dt %}

{% dd %}
Mandatory, can be `{ }`**Type**: Dictionary.**Description**: Object representing the configuration specification for this integration.
{% /dd %}

{% dt %}
`assets[integration[configuration[spec]]]`
{% /dt %}

{% dd %}
Mandatory**Type**: String.**Description**: Relative path to where the configuration spec lives in relation to this manifest.
{% /dd %}

{% dt %}
`assets[integration[events]]`
{% /dt %}

{% dd %}
Mandatory**Type**: Dictionary.**Description**: Information about events emitted by this integration.
{% /dd %}

{% dt %}
`assets[integration[events[creates_events]]]`
{% /dt %}

{% dd %}
Mandatory**Type**: Boolean.**Description**: Whether or not this integration emits events to Datadog.
{% /dd %}

{% dt %}
`assets[integration[metrics]]`
{% /dt %}

{% dd %}
Mandatory**Type**: Dictionary.**Description**: Information about the metrics this integration emits.
{% /dd %}

{% dt %}
`assets[integration[metrics[check]]]`
{% /dt %}

{% dd %}
Mandatory**Type**: String or list of strings.**Description**: A string or list representing metrics that this integration always emits on every run.
{% /dd %}

{% dt %}
`assets[integration[metrics[metadata_path]]]`
{% /dt %}

{% dd %}
Mandatory**Type**: String.**Description**: Relative path to where the metrics metadata lives in relation to this manifest.
{% /dd %}

{% dt %}
`assets[integration[metrics[prefix]]]`
{% /dt %}

{% dd %}
Mandatory**Type**: String.**Description**: The prefix for metrics emitted by this integration.
{% /dd %}

{% dt %}
`assets[integration[service_checks]]`
{% /dt %}

{% dd %}
Mandatory, can be `{ }`**Type**: Dictionary.**Description**: Information about service checks emitted by this integration.
{% /dd %}

{% dt %}
`assets[integration[service_checks[metadata_path]]]`
{% /dt %}

{% dd %}
Mandatory**Type**: String.**Description**: Relative path to where the service check metadata lives in relation to this manifest.
{% /dd %}

{% dt %}
`assets[integration[source_type_name]]`
{% /dt %}

{% dd %}
Mandatory**Type**: String.**Description**: User-facing name of this integration.
{% /dd %}

{% dt %}
`assets[integration[source_type_id]]`
{% /dt %}

{% dd %}
Mandatory**Type**: Integer.**Description**: Globally unique ID for this integration. This is automatically generated by Datadog when the developer toolkit [`ddev create` command](https://docs.datadoghq.com/developers/integrations/create_a_tile/?tab=buildatileontheintegrationspage#populate-the-integration-tile-scaffolding) runs as part of creating tile scaffolding for your integration tile.
{% /dd %}

{% dt %}
`assets[monitors]`
{% /dt %}

{% dd %}
Optional**Type**: Dictionary.**Description**: Recommended monitors.
{% /dd %}

{% dt %}
`assets[monitors["monitor_short_name"]]`
{% /dt %}

{% dd %}
Mandatory**Type**: String.**Description**: Key and value pairs for any recommended monitors. The key is the globally unique short name of the monitor and the value is the relative path to the monitor's JSON definition in relation to this manifest.
{% /dd %}

{% dt %}
`author`
{% /dt %}

{% dd %}
Mandatory**Type**: Dictionary.**Description**: Information about the author of this app.
{% /dd %}

{% dt %}
`author[homepage]`
{% /dt %}

{% dd %}
Mandatory**Type**: String (URL).**Description**: The web URL to the homepage of the author.
{% /dd %}

{% dt %}
`author[name]`
{% /dt %}

{% dd %}
Mandatory**Type**: String.**Description**: The human-readable name for this company.
{% /dd %}

{% dt %}
`author[sales_email]`
{% /dt %}

{% dd %}
Mandatory**Type**: String (Email).**Description**: The Partner email to contact for any subscription-level events.
{% /dd %}

{% dt %}
`author[support_email]`
{% /dt %}

{% dd %}
Mandatory**Type**: String (Email).**Description**: The Partner email to contact for any support and maintenance queries.
{% /dd %}

{% dt %}
`author[contact_link]`
{% /dt %}

{% dd %}
Optional**Type**: String (URL).**Description**: The URL link to meeting scheduling software, such as Calendly. This field is mandatory for professional services listings.
{% /dd %}

{% dt %}
`author[vendor_id]`
{% /dt %}

{% dd %}
Mandatory**Type**: String.**Description**: The vendor ID to use for subscription purposes. Must be globally unique and cannot be changed. Should follow the strict standards of `app_id` where only dashes and alphabetic chars are allowed. This value is provided to Datadog Technology Partners.
{% /dd %}

{% dt %}
`display_on_public_website`
{% /dt %}

{% dd %}
Mandatory**Type**: Boolean.**Description**: Whether or not information about this listing is displayed on the public Datadog Docs site. Once this is set to `true`, it cannot be changed.
{% /dd %}

{% dt %}
`legal_terms`
{% /dt %}

{% dd %}
Mandatory**Type**: Dictionary.**Description**: Any legal documentation that a user needs to agree to in order to use this app.
{% /dd %}

{% dt %}
`legal_terms[eula]`
{% /dt %}

{% dd %}
Mandatory**Type**: String.**Description**: Relative path to the End User License Agreement (EULA) PDF in relation to this manifest.
{% /dd %}

{% dt %}
`pricing`
{% /dt %}

{% dd %}
Mandatory**Type**: Array of Dictionaries.**Description**: List of objects representing the pricing model of the integration. See the [Marketplace GitHub repository](https://github.com/DataDog/marketplace#pricing) for pricing details. The Marketplace GitHub repository is private, [email `marketplace@datadog.com`](mailto:marketplace@datadoghq.com) for access.
{% /dd %}

{% dt %}
`tile`
{% /dt %}

{% dd %}
Mandatory**Type**: Dictionary.**Description**: Information about this offering.
{% /dd %}

{% dt %}
`tile[description]`
{% /dt %}

{% dd %}
Mandatory**Type**: String[80].**Description**: A brief description of what this offering provides. Limited to 80 characters.
{% /dd %}

{% dt %}
`tile[title]`
{% /dt %}

{% dd %}
Mandatory**Type**: String[50].**Description**: The user-friendly title for this app.
{% /dd %}

{% dt %}
`tile[media]`
{% /dt %}

{% dd %}
Mandatory, can be `[ ]`**Type**: Array of Dictionaries.**Description**: Information about the various image and video style objects that are presented in the media gallery carousel on the listing page.
{% /dd %}

{% dt %}
`tile[media[media_type]]`
{% /dt %}

{% dd %}
Mandatory**Type**: String or Enum.**Description**: The type of media this is. Allowed values are `image` and `video`.
{% /dd %}

{% dt %}
`tile[media[caption]]`
{% /dt %}

{% dd %}
Mandatory**Type**: String.**Description**: The caption for the image.
{% /dd %}

{% dt %}
`tile[media[image_url]]`
{% /dt %}

{% dd %}
Mandatory**Type**: String.**Description**: The relative path to this image in relation to this manifest file.
{% /dd %}

{% dt %}
`tile[classifier_tags]`
{% /dt %}

{% dd %}
Mandatory, can be `[ ]`**Type**: Array of strings.**Description**: Select and use the appropriate classifiers to describe this app, including `categories`, `submitted or queried data types`, `supported_os`, and `available_offerings`. For more information, see [Classifier Tags](https://docs.datadoghq.com/developers/integrations/check_references/#classifier-tags).
{% /dd %}

{% dt %}
`tile[resources]`
{% /dt %}

{% dd %}
Optional**Type**: Array of Dictionaries.**Description**: List of externally hosted resources (blog posts, documentation, etc.) that appear in the "Dive Deeper" section of the integration tile with rich previews.
{% /dd %}

{% dt %}
`tile[resources[resource_type]]`
{% /dt %}

{% dd %}
Mandatory**Type**: String.**Description**: Type of resource being linked. Can be `blog`, `documentation`, `faq`, or `other`.
{% /dd %}

{% dt %}
`tile[resources[url]]`
{% /dt %}

{% dd %}
Mandatory**Type**: String.**Description**: Link to resource.
{% /dd %}

{% /dl %}

### Classifier tags{% #classifier-tags %}

You can set multiple categories and define submitted or queried data types for the integration using the `classifier_tags` parameter.

You can find the complete list of classifier tags for the `manifest.json` file below:

| Name                                 | Description                                                                                                                                                                       |
| ------------------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Category::AI                         | Integrations that monitor AI technologies.                                                                                                                                        |
| Category::Alerting                   | Integrations that collect Datadog data to alert on, or send alerts into Datadog.                                                                                                  |
| Category::Automation                 | Integrations for technologies that automate processes such as security, compliance, testing, and AIOps.                                                                           |
| Category::AWS                        | Integrations that send in data from Amazon Web Services and its related services.                                                                                                 |
| Category::Azure                      | Integrations that send in data from Azure and its related services.                                                                                                               |
| Category::Caching                    | Integrations that monitor caches and caching technologies.                                                                                                                        |
| Category::Cloud                      | Integrations that submit data from cloud platforms and their related services.                                                                                                    |
| Category::Collaboration              | Integrations for platforms that center around communication and collaboration, such as code collaboration, messaging software, and conference calling.                            |
| Category::Compliance                 | Integrations that monitor and send compliance data into Datadog, such as support for HIPPA, SOC2, GDPR, and more.                                                                 |
| Category::Configuration & Deployment | Integrations that monitor platforms that can configure and deploy infrastructure.                                                                                                 |
| Category::Containers                 | Integrations that track metrics, logs, events, and traces from containers and container management technologies.                                                                  |
| Category::Cost Management            | Integrations that help track and manage cloud cost.                                                                                                                               |
| Category::Data Stores                | Integrations that monitor data storage solutions such as databases, clusters, data lakes, and more.                                                                               |
| Category::Developer Tools            | Integrations for technologies that developers use to help build applications such as version control, CI/CD, and infrastructure as code.                                          |
| Category::Event Management           | Integrations that send events into Datadog or query events to send into external platforms.                                                                                       |
| Category::Google Cloud               | Integrations that send in data from Google Cloud and its related services.                                                                                                        |
| Category::Incidents                  | Integrations that send incidents into Datadog, or create incidents externally based on Datadog data.                                                                              |
| Category::IOT                        | Integrations that monitor IoT (Internet of Things) devices.                                                                                                                       |
| Category::Issue Tracking             | Integrations that help users identify and manage issues in their infrastructure or code.                                                                                          |
| Category::Kubernetes                 | Integrations that send in data from Kubernetes and Kubernetes-related services.                                                                                                   |
| Category::Languages                  | Integrations that send metrics and additional data based on specific programming languages.                                                                                       |
| Category::Log Collection             | Integrations that submit or query logs from Datadog.                                                                                                                              |
| Category::Machine Learning & LLM     | Integrations that monitor Machine Learning technologies, Large Language Models, and assist with ML Operations.                                                                    |
| Category::Mainframe                  | Integrations that monitor mainframe systems such as IBM z/OS.                                                                                                                     |
| Category::Marketplace                | Integrations that are sold in the Datadog Marketplace for an additional fee.                                                                                                      |
| Category::Messaging                  | Integrations that monitor messaging queues and messaging systems.                                                                                                                 |
| Category::Metrics                    | Integrations that submit and query metrics from Datadog.                                                                                                                          |
| Category::Mobile                     | Integrations that monitor mobile devices and applications.                                                                                                                        |
| Category::Network                    | Integrations that monitor networks and network devices.                                                                                                                           |
| Category::Notifications              | Integrations for technologies that focus on notifications, for example, incident response.                                                                                        |
| Category::Oracle                     | Integrations that monitor Oracle-based technologies.                                                                                                                              |
| Category::Orchestration              | Integrations for technologies that provide orchestration for containers and more.                                                                                                 |
| Category::OS & System                | Integrations that monitor operating systems or other low-level systems.                                                                                                           |
| Category::Provisioning               | Integrations for technologies that manage the provisioning of resources across the cloud, containers, and more.                                                                   |
| Category::SAP                        | Integrations for SAP technologies.                                                                                                                                                |
| Category::Security                   | Integrations that monitor security tools or provide security reporting.                                                                                                           |
| Category::SNMP                       | Integrations that monitor SNMP and related tools.                                                                                                                                 |
| Category::Source Control             | Integrations that monitor source code collaboration tools such as Git.                                                                                                            |
| Category::Testing                    | Integrations that monitor technologies that run browser tests, load testing, and more.                                                                                            |
| Category::Tracing                    | Integrations that send in or query traces from Datadog, and interact with Datadog APM.                                                                                            |
| Offering::Integration                | This is an offering that submits or queries data from a user's Datadog account.                                                                                                   |
| Offering::Professional Service       | This is a paid offering that provides third-party professional services, such as consulting, integration creation, and more to Datadog customers through the Datadog Marketplace. |
| Offering::Software License           | This is a paid offering that provides a subscription to a SaaS product through the Datadog Marketplace.                                                                           |
| Offering::UI Extension               | This is a custom dashboard widget that displays a rendered, interactive iFrame on the dashboards of Datadog users.                                                                |
| Queried Data Type::Metrics           | An integration that reads metrics from a Datadog user's account.                                                                                                                  |
| Queried Data Type::Logs              | An integration that reads logs from a Datadog user's account.                                                                                                                     |
| Queried Data Type::Traces            | An integration that reads traces from a Datadog user's account.                                                                                                                   |
| Queried Data Type::Events            | An integration that reads events from a Datadog user's account.                                                                                                                   |
| Queried Data Type::Incidents         | An integration that reads incidents from a Datadog user's account.                                                                                                                |
| Submitted Data Type::Metrics         | An integration that sends metrics into a Datadog user's account.                                                                                                                  |
| Submitted Data Type::Logs            | An integration that sends logs into a Datadog user's account.                                                                                                                     |
| Submitted Data Type::Traces          | An integration that sends traces into a Datadog user's account.                                                                                                                   |
| Submitted Data Type::Events          | An integration that sends events into a Datadog user's account.                                                                                                                   |
| Submitted Data Type::Incidents       | An integration that sends incidents into a Datadog user's account.                                                                                                                |
| Supported OS::Android                | An integration that can run on and query/submit data from Android.                                                                                                                |
| Supported OS::Any                    | An integration that can run on and query/submit data from any OS.                                                                                                                 |
| Supported OS::HP-UX                  | An integration that can run on and query/submit data from HP-UX.                                                                                                                  |
| Supported OS::IBM i/OS               | An integration that can run on and query/submit data from IBM i/OS.                                                                                                               |
| Supported OS::IBM z/OS               | An integration that can run on and query/submit data from IBM z/OS.                                                                                                               |
| Supported OS::iOS                    | An integration that can run on and query/submit data from iOS.                                                                                                                    |
| Supported OS::Linux                  | An integration that can run on and query/submit data from Linux.                                                                                                                  |
| Supported OS::macOS                  | An integration that can run on and query/submit data from macOS.                                                                                                                  |
| Supported OS::Solaris                | An integration that can run on and query/submit data from Solaris.                                                                                                                |
| Supported OS::Windows                | An integration that can run on and query/submit data from Windows.                                                                                                                |

## Service check file{% #service-check-file %}

The `service_check.json` file describes the service checks made by the integration.

You can find the complete list of mandatory attributes for the `service_checks.json` file below:

| Attribute       | Description                                                                                                              |
| --------------- | ------------------------------------------------------------------------------------------------------------------------ |
| `agent_version` | Minimum Agent version supported.                                                                                         |
| `integration`   | The name of the integration that emits this service check. Must be the non-normalized `tile.title` from `manifest.json`. |
| `check`         | Name of the service check. It must be unique.                                                                            |
| `statuses`      | List of different status of the check, to choose among `ok`, `warning`, and `critical`. `unknown` is also a possibility. |
| `groups`        | [Tags](https://docs.datadoghq.com/getting_started/tagging/) sent with the service check.                                 |
| `name`          | Displayed name of the service check. The displayed name must be self-explanatory and unique across all integrations.     |
| `description`   | Description of the service check.                                                                                        |

## Metrics metadata file{% #metrics-metadata-file %}

The `metadata.csv` file describes all of the metrics that can be collected by the integration.

You can find the complete list of mandatory and optional attributes for the `metadata.csv` file below:

| Column name      | Mandatory or Optional | Description                                                                                                                                                                                                                                                                                                                                       |
| ---------------- | --------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `metric_name`    | Mandatory             | Name of the metric.                                                                                                                                                                                                                                                                                                                               |
| `metric_type`    | Mandatory             | Type of the metric. For a list of available metric submission types, see [Metrics Types](https://docs.datadoghq.com/metrics/types/#metric-types).                                                                                                                                                                                                 |
| `interval`       | Optional              | Collection interval of the metric in seconds.                                                                                                                                                                                                                                                                                                     |
| `unit_name`      | Optional              | Unit of the metric. For a complete list of supported units, see [Metrics Units](https://docs.datadoghq.com/metrics/units/#unit-list).                                                                                                                                                                                                             |
| `per_unit_name`  | Optional              | If there is a unit sub-division, such as `request per second`.                                                                                                                                                                                                                                                                                    |
| `description`    | Optional              | Description of the metric.                                                                                                                                                                                                                                                                                                                        |
| `orientation`    | Mandatory             | Set to `1` if the metric should go up, such as `myapp.turnover`. Set to `0` if the metric variations are irrelevant. Set to `-1` if the metric should go down, such as `myapp.latency`.                                                                                                                                                           |
| `integration`    | Mandatory             | The name of the integration that emits the metric. Must be the normalized version of the `tile.title` from the `manifest.json` file. Any character besides letters, underscores, dashes, and numbers are converted to underscores. For example: `Openstack Controller` -> `openstack_controller`, `ASP.NET` -> `asp_net`, and `CRI-o` -> `cri-o`. |
| `short_name`     | Mandatory             | A human-readable, abbreviated version of the metric name. Do not repeat the integration name. For example, `postgresql.index_blocks_hit` should be shortened to `idx blks hit`.                                                                                                                                                                   |
| `curated_metric` | Optional              | Marks which metrics for an integration are noteworthy for a given type (`cpu` and `memory` are both accepted). These are displayed in the UI above the other integration metrics.                                                                                                                                                                 |
| `sample_tags`    | Optional              | List of example tags associated with the metric, separated by commas (no spaces) and enclosed in quotes. For example, `"host,region,deployment"`.                                                                                                                                                                                                 |

## Further Reading{% #further-reading %}

- [Contributing Guidelines for the Documentation Site](https://github.com/DataDog/documentation/blob/master/CONTRIBUTING.md)
- [Learn about creating an Agent or API-based integration](https://docs.datadoghq.com/developers/integrations/)
- [Learn about using OAuth for API-based integrations](https://docs.datadoghq.com/developers/integrations/api_integration/)