Sign in Dashboard Get started
  1. Packages
  2. Packages
  3. Datadog Provider
  4. API Docs
  5. TeamConnection
Viewing docs for Datadog v5.3.0
published on Friday, May 22, 2026 by Pulumi
Schema (JSON)
pulumi/pulumi-datadog

datadog.TeamConnection

datadog logo
Viewing docs for Datadog v5.3.0
published on Friday, May 22, 2026 by Pulumi
Schema (JSON)
pulumi/pulumi-datadog

    Provides a Datadog Team Connection resource. This can be used to create and manage connections between a Datadog team and an external team (e.g. GitHub).

    Example Usage

    import * as pulumi from "@pulumi/pulumi";
import * as datadog from "@pulumi/datadog";

const example = new datadog.Team("example", {
    description: "Example team",
    handle: "example-team",
    name: "Example Team",
});
// Create a connection between a Datadog team and a GitHub team
const exampleTeamConnection = new datadog.TeamConnection("example", {
    team: [{
        id: example.id,
        type: "team",
    }],
    connectedTeam: [{
        id: "@GitHubOrg/team-handle",
        type: "github_team",
    }],
});

    import pulumi
import pulumi_datadog as datadog

example = datadog.Team("example",
    description="Example team",
    handle="example-team",
    name="Example Team")
# Create a connection between a Datadog team and a GitHub team
example_team_connection = datadog.TeamConnection("example",
    team=[{
        "id": example.id,
        "type": "team",
    }],
    connected_team=[{
        "id": "@GitHubOrg/team-handle",
        "type": "github_team",
    }])

    package main

import (
	"github.com/pulumi/pulumi-datadog/sdk/v5/go/datadog"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		example, err := datadog.NewTeam(ctx, "example", &datadog.TeamArgs{
			Description: pulumi.String("Example team"),
			Handle:      pulumi.String("example-team"),
			Name:        pulumi.String("Example Team"),
		})
		if err != nil {
			return err
		}
		// Create a connection between a Datadog team and a GitHub team
		_, err = datadog.NewTeamConnection(ctx, "example", &datadog.TeamConnectionArgs{
			Team: datadog.TeamConnectionTeamArgs{
				map[string]interface{}{
					"id":   example.ID(),
					"type": "team",
				},
			},
			ConnectedTeam: datadog.TeamConnectionConnectedTeamArgs{
				map[string]interface{}{
					"id":   "@GitHubOrg/team-handle",
					"type": "github_team",
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

    using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Datadog = Pulumi.Datadog;

return await Deployment.RunAsync(() => 
{
    var example = new Datadog.Team("example", new()
    {
        Description = "Example team",
        Handle = "example-team",
        Name = "Example Team",
    });

    // Create a connection between a Datadog team and a GitHub team
    var exampleTeamConnection = new Datadog.TeamConnection("example", new()
    {
        Team = new[]
        {
            
            {
                { "id", example.Id },
                { "type", "team" },
            },
        },
        ConnectedTeam = new[]
        {
            
            {
                { "id", "@GitHubOrg/team-handle" },
                { "type", "github_team" },
            },
        },
    });

});

    package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.datadog.Team;
import com.pulumi.datadog.TeamArgs;
import com.pulumi.datadog.TeamConnection;
import com.pulumi.datadog.TeamConnectionArgs;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        var example = new Team("example", TeamArgs.builder()
            .description("Example team")
            .handle("example-team")
            .name("Example Team")
            .build());

        // Create a connection between a Datadog team and a GitHub team
        var exampleTeamConnection = new TeamConnection("exampleTeamConnection", TeamConnectionArgs.builder()
            .team(TeamConnectionTeamArgs.builder()
                .id(example.id())
                .type("team")
                .build())
            .connectedTeam(TeamConnectionConnectedTeamArgs.builder()
                .id("@GitHubOrg/team-handle")
                .type("github_team")
                .build())
            .build());

    }
}

    resources:
  example:
    type: datadog:Team
    properties:
      description: Example team
      handle: example-team
      name: Example Team
  # Create a connection between a Datadog team and a GitHub team
  exampleTeamConnection:
    type: datadog:TeamConnection
    name: example
    properties:
      team:
        - id: ${example.id}
          type: team
      connectedTeam:
        - id: '@GitHubOrg/team-handle'
          type: github_team

    pulumi {
  required_providers {
    datadog = {
      source = "pulumi/datadog"
    }
  }
}

resource "datadog_team" "example" {
  description = "Example team"
  handle      = "example-team"
  name        = "Example Team"
}
# Create a connection between a Datadog team and a GitHub team
resource "datadog_teamconnection" "example" {
  team = [{
    "id"   = datadog_team.example.id
    "type" = "team"
  }]
  connected_team = [{
    "id"   = "@GitHubOrg/team-handle"
    "type" = "github_team"
  }]
}

    Create TeamConnection Resource

    Resources are created with functions called constructors. To learn more about declaring and configuring resources, see Resources.

    Constructor syntax

    new TeamConnection(name: string, args: TeamConnectionArgs, opts?: CustomResourceOptions);
    @overload
def TeamConnection(resource_name: str,
                   args: TeamConnectionArgs,
                   opts: Optional[ResourceOptions] = None)

@overload
def TeamConnection(resource_name: str,
                   opts: Optional[ResourceOptions] = None,
                   connected_team: Optional[TeamConnectionConnectedTeamArgs] = None,
                   team: Optional[TeamConnectionTeamArgs] = None,
                   source: Optional[str] = None)
    func NewTeamConnection(ctx *Context, name string, args TeamConnectionArgs, opts ...ResourceOption) (*TeamConnection, error)
    public TeamConnection(string name, TeamConnectionArgs args, CustomResourceOptions? opts = null)
    public TeamConnection(String name, TeamConnectionArgs args)
public TeamConnection(String name, TeamConnectionArgs args, CustomResourceOptions options)

    type: datadog:TeamConnection
properties: # The arguments to resource properties.
options: # Bag of options to control resource's behavior.


    resource "datadog_teamconnection" "name" {
    # resource properties
}

    Parameters

    name string
    The unique name of the resource.
    args TeamConnectionArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    resource_name str
    The unique name of the resource.
    args TeamConnectionArgs
    The arguments to resource properties.
    opts ResourceOptions
    Bag of options to control resource's behavior.
    ctx Context
    Context object for the current deployment.
    name string
    The unique name of the resource.
    args TeamConnectionArgs
    The arguments to resource properties.
    opts ResourceOption
    Bag of options to control resource's behavior.
    name string
    The unique name of the resource.
    args TeamConnectionArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    name String
    The unique name of the resource.
    args TeamConnectionArgs
    The arguments to resource properties.
    options CustomResourceOptions
    Bag of options to control resource's behavior.

    Constructor example

    The following reference example uses placeholder values for all input properties.

    var teamConnectionResource = new Datadog.TeamConnection("teamConnectionResource", new()
{
    ConnectedTeam = new Datadog.Inputs.TeamConnectionConnectedTeamArgs
    {
        Id = "string",
        Type = "string",
    },
    Team = new Datadog.Inputs.TeamConnectionTeamArgs
    {
        Id = "string",
        Type = "string",
    },
    Source = "string",
});

    example, err := datadog.NewTeamConnection(ctx, "teamConnectionResource", &datadog.TeamConnectionArgs{
	ConnectedTeam: &datadog.TeamConnectionConnectedTeamArgs{
		Id:   pulumi.String("string"),
		Type: pulumi.String("string"),
	},
	Team: &datadog.TeamConnectionTeamArgs{
		Id:   pulumi.String("string"),
		Type: pulumi.String("string"),
	},
	Source: pulumi.String("string"),
})

    resource "datadog_teamconnection" "teamConnectionResource" {
  connected_team = {
    id   = "string"
    type = "string"
  }
  team = {
    id   = "string"
    type = "string"
  }
  source = "string"
}

    var teamConnectionResource = new TeamConnection("teamConnectionResource", TeamConnectionArgs.builder()
    .connectedTeam(TeamConnectionConnectedTeamArgs.builder()
        .id("string")
        .type("string")
        .build())
    .team(TeamConnectionTeamArgs.builder()
        .id("string")
        .type("string")
        .build())
    .source("string")
    .build());

    team_connection_resource = datadog.TeamConnection("teamConnectionResource",
    connected_team={
        "id": "string",
        "type": "string",
    },
    team={
        "id": "string",
        "type": "string",
    },
    source="string")

    const teamConnectionResource = new datadog.TeamConnection("teamConnectionResource", {
    connectedTeam: {
        id: "string",
        type: "string",
    },
    team: {
        id: "string",
        type: "string",
    },
    source: "string",
});

    type: datadog:TeamConnection
properties:
    connectedTeam:
        id: string
        type: string
    source: string
    team:
        id: string
        type: string

    TeamConnection Resource Properties

    To learn more about resource properties and how to use them, see Inputs and Outputs in the Architecture and Concepts docs.

    Inputs

    In Python, inputs that are objects can be passed either as argument classes or as dictionary literals.

    The TeamConnection resource accepts the following input properties:

    ConnectedTeam TeamConnectionConnectedTeam
    The external connected team reference (e.g. a GitHub team).
    Team TeamConnectionTeam
    The Datadog team reference.
    Source string
    The source of the connection (e.g. github).
    ConnectedTeam TeamConnectionConnectedTeamArgs
    The external connected team reference (e.g. a GitHub team).
    Team TeamConnectionTeamArgs
    The Datadog team reference.
    Source string
    The source of the connection (e.g. github).
    connected_team object
    The external connected team reference (e.g. a GitHub team).
    team object
    The Datadog team reference.
    source string
    The source of the connection (e.g. github).
    connectedTeam TeamConnectionConnectedTeam
    The external connected team reference (e.g. a GitHub team).
    team TeamConnectionTeam
    The Datadog team reference.
    source String
    The source of the connection (e.g. github).
    connectedTeam TeamConnectionConnectedTeam
    The external connected team reference (e.g. a GitHub team).
    team TeamConnectionTeam
    The Datadog team reference.
    source string
    The source of the connection (e.g. github).
    connected_team TeamConnectionConnectedTeamArgs
    The external connected team reference (e.g. a GitHub team).
    team TeamConnectionTeamArgs
    The Datadog team reference.
    source str
    The source of the connection (e.g. github).
    connectedTeam Property Map
    The external connected team reference (e.g. a GitHub team).
    team Property Map
    The Datadog team reference.
    source String
    The source of the connection (e.g. github).

    Outputs

    All input properties are implicitly available as output properties. Additionally, the TeamConnection resource produces the following output properties:

    Id string
    The provider-assigned unique ID for this managed resource.
    Id string
    The provider-assigned unique ID for this managed resource.
    id string
    The provider-assigned unique ID for this managed resource.
    id String
    The provider-assigned unique ID for this managed resource.
    id string
    The provider-assigned unique ID for this managed resource.
    id str
    The provider-assigned unique ID for this managed resource.
    id String
    The provider-assigned unique ID for this managed resource.

    Look up Existing TeamConnection Resource

    Get an existing TeamConnection resource’s state with the given name, ID, and optional extra properties used to qualify the lookup.

    public static get(name: string, id: Input<ID>, state?: TeamConnectionState, opts?: CustomResourceOptions): TeamConnection
    @staticmethod
def get(resource_name: str,
        id: str,
        opts: Optional[ResourceOptions] = None,
        connected_team: Optional[TeamConnectionConnectedTeamArgs] = None,
        source: Optional[str] = None,
        team: Optional[TeamConnectionTeamArgs] = None) -> TeamConnection
    func GetTeamConnection(ctx *Context, name string, id IDInput, state *TeamConnectionState, opts ...ResourceOption) (*TeamConnection, error)
    public static TeamConnection Get(string name, Input<string> id, TeamConnectionState? state, CustomResourceOptions? opts = null)
    public static TeamConnection get(String name, Output<String> id, TeamConnectionState state, CustomResourceOptions options)
    resources:  _:    type: datadog:TeamConnection    get:      id: ${id}
    import {
  to = datadog_teamconnection.example
  id = "${id}"
}
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    resource_name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    The following state arguments are supported:
    ConnectedTeam TeamConnectionConnectedTeam
    The external connected team reference (e.g. a GitHub team).
    Source string
    The source of the connection (e.g. github).
    Team TeamConnectionTeam
    The Datadog team reference.
    ConnectedTeam TeamConnectionConnectedTeamArgs
    The external connected team reference (e.g. a GitHub team).
    Source string
    The source of the connection (e.g. github).
    Team TeamConnectionTeamArgs
    The Datadog team reference.
    connected_team object
    The external connected team reference (e.g. a GitHub team).
    source string
    The source of the connection (e.g. github).
    team object
    The Datadog team reference.
    connectedTeam TeamConnectionConnectedTeam
    The external connected team reference (e.g. a GitHub team).
    source String
    The source of the connection (e.g. github).
    team TeamConnectionTeam
    The Datadog team reference.
    connectedTeam TeamConnectionConnectedTeam
    The external connected team reference (e.g. a GitHub team).
    source string
    The source of the connection (e.g. github).
    team TeamConnectionTeam
    The Datadog team reference.
    connected_team TeamConnectionConnectedTeamArgs
    The external connected team reference (e.g. a GitHub team).
    source str
    The source of the connection (e.g. github).
    team TeamConnectionTeamArgs
    The Datadog team reference.
    connectedTeam Property Map
    The external connected team reference (e.g. a GitHub team).
    source String
    The source of the connection (e.g. github).
    team Property Map
    The Datadog team reference.

    Supporting Types

    TeamConnectionConnectedTeam, TeamConnectionConnectedTeamArgs

    Id string
    The ID of the external connected team.
    Type string
    The resource type of the external connected team. Valid values are githubTeam.
    Id string
    The ID of the external connected team.
    Type string
    The resource type of the external connected team. Valid values are githubTeam.
    id string
    The ID of the external connected team.
    type string
    The resource type of the external connected team. Valid values are githubTeam.
    id String
    The ID of the external connected team.
    type String
    The resource type of the external connected team. Valid values are githubTeam.
    id string
    The ID of the external connected team.
    type string
    The resource type of the external connected team. Valid values are githubTeam.
    id str
    The ID of the external connected team.
    type str
    The resource type of the external connected team. Valid values are githubTeam.
    id String
    The ID of the external connected team.
    type String
    The resource type of the external connected team. Valid values are githubTeam.

    TeamConnectionTeam, TeamConnectionTeamArgs

    Id string
    The ID of the Datadog team.
    Type string
    The resource type of the Datadog team. Valid values are team.
    Id string
    The ID of the Datadog team.
    Type string
    The resource type of the Datadog team. Valid values are team.
    id string
    The ID of the Datadog team.
    type string
    The resource type of the Datadog team. Valid values are team.
    id String
    The ID of the Datadog team.
    type String
    The resource type of the Datadog team. Valid values are team.
    id string
    The ID of the Datadog team.
    type string
    The resource type of the Datadog team. Valid values are team.
    id str
    The ID of the Datadog team.
    type str
    The resource type of the Datadog team. Valid values are team.
    id String
    The ID of the Datadog team.
    type String
    The resource type of the Datadog team. Valid values are team.

    Import

    The pulumi import command can be used, for example:

    $ pulumi import datadog:index/teamConnection:TeamConnection example "${connection_id}"

    To learn more about importing existing cloud resources, see Importing resources.

    Package Details

    Repository
    Datadog pulumi/pulumi-datadog
    License
    Apache-2.0
    Notes
    This Pulumi package is based on the datadog Terraform Provider.
    datadog logo
    Viewing docs for Datadog v5.3.0
    published on Friday, May 22, 2026 by Pulumi
    Schema (JSON)
    pulumi/pulumi-datadog

      Try Pulumi Cloud free.
      Your team will thank you.

      Start free trial