newrelic.NotificationDestination (v4)

New Relic v4.20.0 (4.x), Mar 9 26

Viewing docs for New Relic v4.20.0 (Older version)
published on Monday, Mar 9, 2026 by Pulumi

Go to latest version

Schema (JSON)

pulumi/pulumi-newrelic

Viewing docs for New Relic v4.20.0 (Older version)
published on Monday, Mar 9, 2026 by Pulumi

Go to latest version

Schema (JSON)

pulumi/pulumi-newrelic

Additional Examples

ServiceNow

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

const foo = new newrelic.NotificationDestination("foo", {
    auth: {
        password: "pass",
        type: "BASIC",
        user: "user",
    },
    properties: [
        {
            key: "url",
            value: "https://service-now.com/",
        },
        {
            key: "two_way_integration",
            value: "true",
        },
    ],
    type: "SERVICE_NOW",
});

import pulumi
import pulumi_newrelic as newrelic

foo = newrelic.NotificationDestination("foo",
    auth={
        "password": "pass",
        "type": "BASIC",
        "user": "user",
    },
    properties=[
        newrelic.NotificationDestinationPropertyArgs(
            key="url",
            value="https://service-now.com/",
        ),
        newrelic.NotificationDestinationPropertyArgs(
            key="two_way_integration",
            value="true",
        ),
    ],
    type="SERVICE_NOW")

using System.Collections.Generic;
using Pulumi;
using NewRelic = Pulumi.NewRelic;

return await Deployment.RunAsync(() => 
{
    var foo = new NewRelic.NotificationDestination("foo", new()
    {
        Auth = 
        {
            { "password", "pass" },
            { "type", "BASIC" },
            { "user", "user" },
        },
        Properties = new[]
        {
            new NewRelic.Inputs.NotificationDestinationPropertyArgs
            {
                Key = "url",
                Value = "https://service-now.com/",
            },
            new NewRelic.Inputs.NotificationDestinationPropertyArgs
            {
                Key = "two_way_integration",
                Value = "true",
            },
        },
        Type = "SERVICE_NOW",
    });

});

package main

import (
	"github.com/pulumi/pulumi-newrelic/sdk/v4/go/newrelic"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := newrelic.NewNotificationDestination(ctx, "foo", &newrelic.NotificationDestinationArgs{
			Auth: pulumi.StringMap{
				"password": pulumi.String("pass"),
				"type":     pulumi.String("BASIC"),
				"user":     pulumi.String("user"),
			},
			Properties: NotificationDestinationPropertyArray{
				&NotificationDestinationPropertyArgs{
					Key:   pulumi.String("url"),
					Value: pulumi.String("https://service-now.com/"),
				},
				&NotificationDestinationPropertyArgs{
					Key:   pulumi.String("two_way_integration"),
					Value: pulumi.String("true"),
				},
			},
			Type: pulumi.String("SERVICE_NOW"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.newrelic.NotificationDestination;
import com.pulumi.newrelic.NotificationDestinationArgs;
import com.pulumi.newrelic.inputs.NotificationDestinationPropertyArgs;
import java.util.List;
import java.util.ArrayList;
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 foo = new NotificationDestination("foo", NotificationDestinationArgs.builder()        
            .auth(Map.ofEntries(
                Map.entry("password", "pass"),
                Map.entry("type", "BASIC"),
                Map.entry("user", "user")
            ))
            .properties(            
                NotificationDestinationPropertyArgs.builder()
                    .key("url")
                    .value("https://service-now.com/")
                    .build(),
                NotificationDestinationPropertyArgs.builder()
                    .key("two_way_integration")
                    .value("true")
                    .build())
            .type("SERVICE_NOW")
            .build());

    }
}

resources:
  foo:
    type: newrelic:NotificationDestination
    properties:
      auth:
        password: pass
        type: BASIC
        user: user
      properties:
        - key: url
          value: https://service-now.com/
        - key: two_way_integration
          value: true
      type: SERVICE_NOW

Email

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

const foo = new newrelic.NotificationDestination("foo", {
    auth: {
        prefix: "prefix",
        token: "bearer",
        type: "TOKEN",
    },
    properties: [{
        key: "email",
        value: "email@email.com,email2@email.com",
    }],
    type: "EMAIL",
});

import pulumi
import pulumi_newrelic as newrelic

foo = newrelic.NotificationDestination("foo",
    auth={
        "prefix": "prefix",
        "token": "bearer",
        "type": "TOKEN",
    },
    properties=[newrelic.NotificationDestinationPropertyArgs(
        key="email",
        value="email@email.com,email2@email.com",
    )],
    type="EMAIL")

using System.Collections.Generic;
using Pulumi;
using NewRelic = Pulumi.NewRelic;

return await Deployment.RunAsync(() => 
{
    var foo = new NewRelic.NotificationDestination("foo", new()
    {
        Auth = 
        {
            { "prefix", "prefix" },
            { "token", "bearer" },
            { "type", "TOKEN" },
        },
        Properties = new[]
        {
            new NewRelic.Inputs.NotificationDestinationPropertyArgs
            {
                Key = "email",
                Value = "email@email.com,email2@email.com",
            },
        },
        Type = "EMAIL",
    });

});

package main

import (
	"github.com/pulumi/pulumi-newrelic/sdk/v4/go/newrelic"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := newrelic.NewNotificationDestination(ctx, "foo", &newrelic.NotificationDestinationArgs{
			Auth: pulumi.StringMap{
				"prefix": pulumi.String("prefix"),
				"token":  pulumi.String("bearer"),
				"type":   pulumi.String("TOKEN"),
			},
			Properties: NotificationDestinationPropertyArray{
				&NotificationDestinationPropertyArgs{
					Key:   pulumi.String("email"),
					Value: pulumi.String("email@email.com,email2@email.com"),
				},
			},
			Type: pulumi.String("EMAIL"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.newrelic.NotificationDestination;
import com.pulumi.newrelic.NotificationDestinationArgs;
import com.pulumi.newrelic.inputs.NotificationDestinationPropertyArgs;
import java.util.List;
import java.util.ArrayList;
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 foo = new NotificationDestination("foo", NotificationDestinationArgs.builder()        
            .auth(Map.ofEntries(
                Map.entry("prefix", "prefix"),
                Map.entry("token", "bearer"),
                Map.entry("type", "TOKEN")
            ))
            .properties(NotificationDestinationPropertyArgs.builder()
                .key("email")
                .value("email@email.com,email2@email.com")
                .build())
            .type("EMAIL")
            .build());

    }
}

resources:
  foo:
    type: newrelic:NotificationDestination
    properties:
      auth:
        prefix: prefix
        token: bearer
        type: TOKEN
      properties:
        - key: email
          value: email@email.com,email2@email.com
      type: EMAIL

PagerDuty with service integration

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

const foo = new newrelic.NotificationDestination("foo", {
    auth: {
        prefix: "prefix",
        token: "bearer",
        type: "TOKEN",
    },
    properties: [{
        key: "two_way_integration",
        value: "true",
    }],
    type: "PAGERDUTY_SERVICE_INTEGRATION",
});

import pulumi
import pulumi_newrelic as newrelic

foo = newrelic.NotificationDestination("foo",
    auth={
        "prefix": "prefix",
        "token": "bearer",
        "type": "TOKEN",
    },
    properties=[newrelic.NotificationDestinationPropertyArgs(
        key="two_way_integration",
        value="true",
    )],
    type="PAGERDUTY_SERVICE_INTEGRATION")

using System.Collections.Generic;
using Pulumi;
using NewRelic = Pulumi.NewRelic;

return await Deployment.RunAsync(() => 
{
    var foo = new NewRelic.NotificationDestination("foo", new()
    {
        Auth = 
        {
            { "prefix", "prefix" },
            { "token", "bearer" },
            { "type", "TOKEN" },
        },
        Properties = new[]
        {
            new NewRelic.Inputs.NotificationDestinationPropertyArgs
            {
                Key = "two_way_integration",
                Value = "true",
            },
        },
        Type = "PAGERDUTY_SERVICE_INTEGRATION",
    });

});

package main

import (
	"github.com/pulumi/pulumi-newrelic/sdk/v4/go/newrelic"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := newrelic.NewNotificationDestination(ctx, "foo", &newrelic.NotificationDestinationArgs{
			Auth: pulumi.StringMap{
				"prefix": pulumi.String("prefix"),
				"token":  pulumi.String("bearer"),
				"type":   pulumi.String("TOKEN"),
			},
			Properties: NotificationDestinationPropertyArray{
				&NotificationDestinationPropertyArgs{
					Key:   pulumi.String("two_way_integration"),
					Value: pulumi.String("true"),
				},
			},
			Type: pulumi.String("PAGERDUTY_SERVICE_INTEGRATION"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.newrelic.NotificationDestination;
import com.pulumi.newrelic.NotificationDestinationArgs;
import com.pulumi.newrelic.inputs.NotificationDestinationPropertyArgs;
import java.util.List;
import java.util.ArrayList;
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 foo = new NotificationDestination("foo", NotificationDestinationArgs.builder()        
            .auth(Map.ofEntries(
                Map.entry("prefix", "prefix"),
                Map.entry("token", "bearer"),
                Map.entry("type", "TOKEN")
            ))
            .properties(NotificationDestinationPropertyArgs.builder()
                .key("two_way_integration")
                .value("true")
                .build())
            .type("PAGERDUTY_SERVICE_INTEGRATION")
            .build());

    }
}

resources:
  foo:
    type: newrelic:NotificationDestination
    properties:
      auth:
        prefix: prefix
        token: bearer
        type: TOKEN
      properties:
        - key: two_way_integration
          value: true
      type: PAGERDUTY_SERVICE_INTEGRATION

PagerDuty with account integration

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

const foo = new newrelic.NotificationDestination("foo", {
    auth: {
        prefix: "prefix",
        token: "bearer",
        type: "TOKEN",
    },
    type: "PAGERDUTY_ACCOUNT_INTEGRATION",
});

import pulumi
import pulumi_newrelic as newrelic

foo = newrelic.NotificationDestination("foo",
    auth={
        "prefix": "prefix",
        "token": "bearer",
        "type": "TOKEN",
    },
    type="PAGERDUTY_ACCOUNT_INTEGRATION")

using System.Collections.Generic;
using Pulumi;
using NewRelic = Pulumi.NewRelic;

return await Deployment.RunAsync(() => 
{
    var foo = new NewRelic.NotificationDestination("foo", new()
    {
        Auth = 
        {
            { "prefix", "prefix" },
            { "token", "bearer" },
            { "type", "TOKEN" },
        },
        Type = "PAGERDUTY_ACCOUNT_INTEGRATION",
    });

});

package main

import (
	"github.com/pulumi/pulumi-newrelic/sdk/v4/go/newrelic"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := newrelic.NewNotificationDestination(ctx, "foo", &newrelic.NotificationDestinationArgs{
			Auth: pulumi.StringMap{
				"prefix": pulumi.String("prefix"),
				"token":  pulumi.String("bearer"),
				"type":   pulumi.String("TOKEN"),
			},
			Type: pulumi.String("PAGERDUTY_ACCOUNT_INTEGRATION"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.newrelic.NotificationDestination;
import com.pulumi.newrelic.NotificationDestinationArgs;
import java.util.List;
import java.util.ArrayList;
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 foo = new NotificationDestination("foo", NotificationDestinationArgs.builder()        
            .auth(Map.ofEntries(
                Map.entry("prefix", "prefix"),
                Map.entry("token", "bearer"),
                Map.entry("type", "TOKEN")
            ))
            .type("PAGERDUTY_ACCOUNT_INTEGRATION")
            .build());

    }
}

resources:
  foo:
    type: newrelic:NotificationDestination
    properties:
      auth:
        prefix: prefix
        token: bearer
        type: TOKEN
      type: PAGERDUTY_ACCOUNT_INTEGRATION

NOTE: Sensitive data such as destination API keys, service keys, etc are not returned from the underlying API for security reasons and may not be set in state when importing.

Example Usage

using System.Collections.Generic;
using Pulumi;
using NewRelic = Pulumi.NewRelic;

return await Deployment.RunAsync(() => 
{
    var foo = new NewRelic.NotificationDestination("foo", new()
    {
        Auth = 
        {
            { "password", "1234" },
            { "type", "BASIC" },
            { "user", "user" },
        },
        Properties = new[]
        {
            new NewRelic.Inputs.NotificationDestinationPropertyArgs
            {
                Key = "url",
                Value = "https://webhook.site/",
            },
        },
        Type = "WEBHOOK",
    });

});

package main

import (
	"github.com/pulumi/pulumi-newrelic/sdk/v4/go/newrelic"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := newrelic.NewNotificationDestination(ctx, "foo", &newrelic.NotificationDestinationArgs{
			Auth: pulumi.StringMap{
				"password": pulumi.String("1234"),
				"type":     pulumi.String("BASIC"),
				"user":     pulumi.String("user"),
			},
			Properties: NotificationDestinationPropertyArray{
				&NotificationDestinationPropertyArgs{
					Key:   pulumi.String("url"),
					Value: pulumi.String("https://webhook.site/"),
				},
			},
			Type: pulumi.String("WEBHOOK"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.newrelic.NotificationDestination;
import com.pulumi.newrelic.NotificationDestinationArgs;
import com.pulumi.newrelic.inputs.NotificationDestinationPropertyArgs;
import java.util.List;
import java.util.ArrayList;
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 foo = new NotificationDestination("foo", NotificationDestinationArgs.builder()        
            .auth(Map.ofEntries(
                Map.entry("password", "1234"),
                Map.entry("type", "BASIC"),
                Map.entry("user", "user")
            ))
            .properties(NotificationDestinationPropertyArgs.builder()
                .key("url")
                .value("https://webhook.site/")
                .build())
            .type("WEBHOOK")
            .build());

    }
}

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

const foo = new newrelic.NotificationDestination("foo", {
    auth: {
        password: "1234",
        type: "BASIC",
        user: "user",
    },
    properties: [{
        key: "url",
        value: "https://webhook.site/",
    }],
    type: "WEBHOOK",
});

import pulumi
import pulumi_newrelic as newrelic

foo = newrelic.NotificationDestination("foo",
    auth={
        "password": "1234",
        "type": "BASIC",
        "user": "user",
    },
    properties=[newrelic.NotificationDestinationPropertyArgs(
        key="url",
        value="https://webhook.site/",
    )],
    type="WEBHOOK")

resources:
  foo:
    type: newrelic:NotificationDestination
    properties:
      auth:
        password: 1234
        type: BASIC
        user: user
      properties:
        - key: url
          value: https://webhook.site/
      type: WEBHOOK

See additional examples.

using System.Collections.Generic;
using Pulumi;
using NewRelic = Pulumi.NewRelic;

return await Deployment.RunAsync(() => 
{
    var foo = new NewRelic.NotificationDestination("foo", new()
    {
        Auth = 
        {
            { "password", "pass" },
            { "type", "BASIC" },
            { "user", "user" },
        },
        Properties = new[]
        {
            new NewRelic.Inputs.NotificationDestinationPropertyArgs
            {
                Key = "url",
                Value = "https://service-now.com/",
            },
            new NewRelic.Inputs.NotificationDestinationPropertyArgs
            {
                Key = "two_way_integration",
                Value = "true",
            },
        },
        Type = "SERVICE_NOW",
    });

});

package main

import (
	"github.com/pulumi/pulumi-newrelic/sdk/v4/go/newrelic"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := newrelic.NewNotificationDestination(ctx, "foo", &newrelic.NotificationDestinationArgs{
			Auth: pulumi.StringMap{
				"password": pulumi.String("pass"),
				"type":     pulumi.String("BASIC"),
				"user":     pulumi.String("user"),
			},
			Properties: NotificationDestinationPropertyArray{
				&NotificationDestinationPropertyArgs{
					Key:   pulumi.String("url"),
					Value: pulumi.String("https://service-now.com/"),
				},
				&NotificationDestinationPropertyArgs{
					Key:   pulumi.String("two_way_integration"),
					Value: pulumi.String("true"),
				},
			},
			Type: pulumi.String("SERVICE_NOW"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.newrelic.NotificationDestination;
import com.pulumi.newrelic.NotificationDestinationArgs;
import com.pulumi.newrelic.inputs.NotificationDestinationPropertyArgs;
import java.util.List;
import java.util.ArrayList;
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 foo = new NotificationDestination("foo", NotificationDestinationArgs.builder()        
            .auth(Map.ofEntries(
                Map.entry("password", "pass"),
                Map.entry("type", "BASIC"),
                Map.entry("user", "user")
            ))
            .properties(            
                NotificationDestinationPropertyArgs.builder()
                    .key("url")
                    .value("https://service-now.com/")
                    .build(),
                NotificationDestinationPropertyArgs.builder()
                    .key("two_way_integration")
                    .value("true")
                    .build())
            .type("SERVICE_NOW")
            .build());

    }
}

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

const foo = new newrelic.NotificationDestination("foo", {
    auth: {
        password: "pass",
        type: "BASIC",
        user: "user",
    },
    properties: [
        {
            key: "url",
            value: "https://service-now.com/",
        },
        {
            key: "two_way_integration",
            value: "true",
        },
    ],
    type: "SERVICE_NOW",
});

import pulumi
import pulumi_newrelic as newrelic

foo = newrelic.NotificationDestination("foo",
    auth={
        "password": "pass",
        "type": "BASIC",
        "user": "user",
    },
    properties=[
        newrelic.NotificationDestinationPropertyArgs(
            key="url",
            value="https://service-now.com/",
        ),
        newrelic.NotificationDestinationPropertyArgs(
            key="two_way_integration",
            value="true",
        ),
    ],
    type="SERVICE_NOW")

resources:
  foo:
    type: newrelic:NotificationDestination
    properties:
      auth:
        password: pass
        type: BASIC
        user: user
      properties:
        - key: url
          value: https://service-now.com/
        - key: two_way_integration
          value: true
      type: SERVICE_NOW

using System.Collections.Generic;
using Pulumi;
using NewRelic = Pulumi.NewRelic;

return await Deployment.RunAsync(() => 
{
    var foo = new NewRelic.NotificationDestination("foo", new()
    {
        Auth = 
        {
            { "prefix", "prefix" },
            { "token", "bearer" },
            { "type", "TOKEN" },
        },
        Properties = new[]
        {
            new NewRelic.Inputs.NotificationDestinationPropertyArgs
            {
                Key = "email",
                Value = "email@email.com,email2@email.com",
            },
        },
        Type = "EMAIL",
    });

});

package main

import (
	"github.com/pulumi/pulumi-newrelic/sdk/v4/go/newrelic"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := newrelic.NewNotificationDestination(ctx, "foo", &newrelic.NotificationDestinationArgs{
			Auth: pulumi.StringMap{
				"prefix": pulumi.String("prefix"),
				"token":  pulumi.String("bearer"),
				"type":   pulumi.String("TOKEN"),
			},
			Properties: NotificationDestinationPropertyArray{
				&NotificationDestinationPropertyArgs{
					Key:   pulumi.String("email"),
					Value: pulumi.String("email@email.com,email2@email.com"),
				},
			},
			Type: pulumi.String("EMAIL"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.newrelic.NotificationDestination;
import com.pulumi.newrelic.NotificationDestinationArgs;
import com.pulumi.newrelic.inputs.NotificationDestinationPropertyArgs;
import java.util.List;
import java.util.ArrayList;
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 foo = new NotificationDestination("foo", NotificationDestinationArgs.builder()        
            .auth(Map.ofEntries(
                Map.entry("prefix", "prefix"),
                Map.entry("token", "bearer"),
                Map.entry("type", "TOKEN")
            ))
            .properties(NotificationDestinationPropertyArgs.builder()
                .key("email")
                .value("email@email.com,email2@email.com")
                .build())
            .type("EMAIL")
            .build());

    }
}

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

const foo = new newrelic.NotificationDestination("foo", {
    auth: {
        prefix: "prefix",
        token: "bearer",
        type: "TOKEN",
    },
    properties: [{
        key: "email",
        value: "email@email.com,email2@email.com",
    }],
    type: "EMAIL",
});

import pulumi
import pulumi_newrelic as newrelic

foo = newrelic.NotificationDestination("foo",
    auth={
        "prefix": "prefix",
        "token": "bearer",
        "type": "TOKEN",
    },
    properties=[newrelic.NotificationDestinationPropertyArgs(
        key="email",
        value="email@email.com,email2@email.com",
    )],
    type="EMAIL")

resources:
  foo:
    type: newrelic:NotificationDestination
    properties:
      auth:
        prefix: prefix
        token: bearer
        type: TOKEN
      properties:
        - key: email
          value: email@email.com,email2@email.com
      type: EMAIL

using System.Collections.Generic;
using Pulumi;
using NewRelic = Pulumi.NewRelic;

return await Deployment.RunAsync(() => 
{
    var foo = new NewRelic.NotificationDestination("foo", new()
    {
        Auth = 
        {
            { "prefix", "prefix" },
            { "token", "bearer" },
            { "type", "TOKEN" },
        },
        Properties = new[]
        {
            new NewRelic.Inputs.NotificationDestinationPropertyArgs
            {
                Key = "two_way_integration",
                Value = "true",
            },
        },
        Type = "PAGERDUTY_SERVICE_INTEGRATION",
    });

});

package main

import (
	"github.com/pulumi/pulumi-newrelic/sdk/v4/go/newrelic"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := newrelic.NewNotificationDestination(ctx, "foo", &newrelic.NotificationDestinationArgs{
			Auth: pulumi.StringMap{
				"prefix": pulumi.String("prefix"),
				"token":  pulumi.String("bearer"),
				"type":   pulumi.String("TOKEN"),
			},
			Properties: NotificationDestinationPropertyArray{
				&NotificationDestinationPropertyArgs{
					Key:   pulumi.String("two_way_integration"),
					Value: pulumi.String("true"),
				},
			},
			Type: pulumi.String("PAGERDUTY_SERVICE_INTEGRATION"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.newrelic.NotificationDestination;
import com.pulumi.newrelic.NotificationDestinationArgs;
import com.pulumi.newrelic.inputs.NotificationDestinationPropertyArgs;
import java.util.List;
import java.util.ArrayList;
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 foo = new NotificationDestination("foo", NotificationDestinationArgs.builder()        
            .auth(Map.ofEntries(
                Map.entry("prefix", "prefix"),
                Map.entry("token", "bearer"),
                Map.entry("type", "TOKEN")
            ))
            .properties(NotificationDestinationPropertyArgs.builder()
                .key("two_way_integration")
                .value("true")
                .build())
            .type("PAGERDUTY_SERVICE_INTEGRATION")
            .build());

    }
}

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

const foo = new newrelic.NotificationDestination("foo", {
    auth: {
        prefix: "prefix",
        token: "bearer",
        type: "TOKEN",
    },
    properties: [{
        key: "two_way_integration",
        value: "true",
    }],
    type: "PAGERDUTY_SERVICE_INTEGRATION",
});

import pulumi
import pulumi_newrelic as newrelic

foo = newrelic.NotificationDestination("foo",
    auth={
        "prefix": "prefix",
        "token": "bearer",
        "type": "TOKEN",
    },
    properties=[newrelic.NotificationDestinationPropertyArgs(
        key="two_way_integration",
        value="true",
    )],
    type="PAGERDUTY_SERVICE_INTEGRATION")

resources:
  foo:
    type: newrelic:NotificationDestination
    properties:
      auth:
        prefix: prefix
        token: bearer
        type: TOKEN
      properties:
        - key: two_way_integration
          value: true
      type: PAGERDUTY_SERVICE_INTEGRATION

using System.Collections.Generic;
using Pulumi;
using NewRelic = Pulumi.NewRelic;

return await Deployment.RunAsync(() => 
{
    var foo = new NewRelic.NotificationDestination("foo", new()
    {
        Auth = 
        {
            { "prefix", "prefix" },
            { "token", "bearer" },
            { "type", "TOKEN" },
        },
        Type = "PAGERDUTY_ACCOUNT_INTEGRATION",
    });

});

package main

import (
	"github.com/pulumi/pulumi-newrelic/sdk/v4/go/newrelic"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := newrelic.NewNotificationDestination(ctx, "foo", &newrelic.NotificationDestinationArgs{
			Auth: pulumi.StringMap{
				"prefix": pulumi.String("prefix"),
				"token":  pulumi.String("bearer"),
				"type":   pulumi.String("TOKEN"),
			},
			Type: pulumi.String("PAGERDUTY_ACCOUNT_INTEGRATION"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.newrelic.NotificationDestination;
import com.pulumi.newrelic.NotificationDestinationArgs;
import java.util.List;
import java.util.ArrayList;
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 foo = new NotificationDestination("foo", NotificationDestinationArgs.builder()        
            .auth(Map.ofEntries(
                Map.entry("prefix", "prefix"),
                Map.entry("token", "bearer"),
                Map.entry("type", "TOKEN")
            ))
            .type("PAGERDUTY_ACCOUNT_INTEGRATION")
            .build());

    }
}

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

const foo = new newrelic.NotificationDestination("foo", {
    auth: {
        prefix: "prefix",
        token: "bearer",
        type: "TOKEN",
    },
    type: "PAGERDUTY_ACCOUNT_INTEGRATION",
});

import pulumi
import pulumi_newrelic as newrelic

foo = newrelic.NotificationDestination("foo",
    auth={
        "prefix": "prefix",
        "token": "bearer",
        "type": "TOKEN",
    },
    type="PAGERDUTY_ACCOUNT_INTEGRATION")

resources:
  foo:
    type: newrelic:NotificationDestination
    properties:
      auth:
        prefix: prefix
        token: bearer
        type: TOKEN
      type: PAGERDUTY_ACCOUNT_INTEGRATION

Create NotificationDestination Resource

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

Constructor syntax

new NotificationDestination(name: string, args: NotificationDestinationArgs, opts?: CustomResourceOptions);

@overload
def NotificationDestination(resource_name: str,
                            args: NotificationDestinationArgs,
                            opts: Optional[ResourceOptions] = None)

@overload
def NotificationDestination(resource_name: str,
                            opts: Optional[ResourceOptions] = None,
                            type: Optional[str] = None,
                            auth: Optional[Mapping[str, str]] = None,
                            name: Optional[str] = None,
                            properties: Optional[Sequence[NotificationDestinationPropertyArgs]] = None)

func NewNotificationDestination(ctx *Context, name string, args NotificationDestinationArgs, opts ...ResourceOption) (*NotificationDestination, error)

public NotificationDestination(string name, NotificationDestinationArgs args, CustomResourceOptions? opts = null)

public NotificationDestination(String name, NotificationDestinationArgs args)
public NotificationDestination(String name, NotificationDestinationArgs args, CustomResourceOptions options)

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

Parameters

name string: The unique name of the resource.
args NotificationDestinationArgs: 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 NotificationDestinationArgs: 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 NotificationDestinationArgs: The arguments to resource properties.
opts ResourceOption: Bag of options to control resource's behavior.

name string: The unique name of the resource.
args NotificationDestinationArgs: The arguments to resource properties.
opts CustomResourceOptions: Bag of options to control resource's behavior.

name String: The unique name of the resource.
args NotificationDestinationArgs: 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 notificationDestinationResource = new NewRelic.NotificationDestination("notificationDestinationResource", new()
{
    Type = "string",
    Auth = 
    {
        { "string", "string" },
    },
    Name = "string",
    Properties = new[]
    {
        new NewRelic.Inputs.NotificationDestinationPropertyArgs
        {
            Key = "string",
            Value = "string",
            DisplayValue = "string",
            Label = "string",
        },
    },
});

example, err := newrelic.NewNotificationDestination(ctx, "notificationDestinationResource", &newrelic.NotificationDestinationArgs{
	Type: pulumi.String("string"),
	Auth: pulumi.StringMap{
		"string": pulumi.String("string"),
	},
	Name: pulumi.String("string"),
	Properties: newrelic.NotificationDestinationPropertyArray{
		&newrelic.NotificationDestinationPropertyArgs{
			Key:          pulumi.String("string"),
			Value:        pulumi.String("string"),
			DisplayValue: pulumi.String("string"),
			Label:        pulumi.String("string"),
		},
	},
})

var notificationDestinationResource = new NotificationDestination("notificationDestinationResource", NotificationDestinationArgs.builder()
    .type("string")
    .auth(Map.of("string", "string"))
    .name("string")
    .properties(NotificationDestinationPropertyArgs.builder()
        .key("string")
        .value("string")
        .displayValue("string")
        .label("string")
        .build())
    .build());

notification_destination_resource = newrelic.NotificationDestination("notificationDestinationResource",
    type="string",
    auth={
        "string": "string",
    },
    name="string",
    properties=[{
        "key": "string",
        "value": "string",
        "display_value": "string",
        "label": "string",
    }])

const notificationDestinationResource = new newrelic.NotificationDestination("notificationDestinationResource", {
    type: "string",
    auth: {
        string: "string",
    },
    name: "string",
    properties: [{
        key: "string",
        value: "string",
        displayValue: "string",
        label: "string",
    }],
});

type: newrelic:NotificationDestination
properties:
    auth:
        string: string
    name: string
    properties:
        - displayValue: string
          key: string
          label: string
          value: string
    type: string

NotificationDestination 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 NotificationDestination resource accepts the following input properties:

Type string: The type of the auth. One of: TOKEN or BASIC.
Auth Dictionary<string, string>: A nested block that describes a notification destination authentication. Only one auth block is permitted per notification destination definition. See Nested auth blocks below for details.
Name string: The name of the destination.
Properties List<Pulumi.NewRelic.Inputs.NotificationDestinationProperty>: A nested block that describes a notification destination properties. Only one properties block is permitted per notification destination definition. See Nested properties blocks below for details.

Type string: The type of the auth. One of: TOKEN or BASIC.
Auth map[string]string: A nested block that describes a notification destination authentication. Only one auth block is permitted per notification destination definition. See Nested auth blocks below for details.
Name string: The name of the destination.
Properties []NotificationDestinationPropertyArgs: A nested block that describes a notification destination properties. Only one properties block is permitted per notification destination definition. See Nested properties blocks below for details.

type String: The type of the auth. One of: TOKEN or BASIC.
auth Map<String,String>: A nested block that describes a notification destination authentication. Only one auth block is permitted per notification destination definition. See Nested auth blocks below for details.
name String: The name of the destination.
properties List<NotificationDestinationProperty>: A nested block that describes a notification destination properties. Only one properties block is permitted per notification destination definition. See Nested properties blocks below for details.

type string: The type of the auth. One of: TOKEN or BASIC.
auth {[key: string]: string}: A nested block that describes a notification destination authentication. Only one auth block is permitted per notification destination definition. See Nested auth blocks below for details.
name string: The name of the destination.
properties NotificationDestinationProperty[]: A nested block that describes a notification destination properties. Only one properties block is permitted per notification destination definition. See Nested properties blocks below for details.

type str: The type of the auth. One of: TOKEN or BASIC.
auth Mapping[str, str]: A nested block that describes a notification destination authentication. Only one auth block is permitted per notification destination definition. See Nested auth blocks below for details.
name str: The name of the destination.
properties Sequence[NotificationDestinationPropertyArgs]: A nested block that describes a notification destination properties. Only one properties block is permitted per notification destination definition. See Nested properties blocks below for details.

type String: The type of the auth. One of: TOKEN or BASIC.
auth Map<String>: A nested block that describes a notification destination authentication. Only one auth block is permitted per notification destination definition. See Nested auth blocks below for details.
name String: The name of the destination.
properties List<Property Map>: A nested block that describes a notification destination properties. Only one properties block is permitted per notification destination definition. See Nested properties blocks below for details.

Outputs

All input properties are implicitly available as output properties. Additionally, the NotificationDestination 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 str: The provider-assigned unique ID for this managed resource.

id String: The provider-assigned unique ID for this managed resource.

Look up Existing NotificationDestination Resource

Get an existing NotificationDestination 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?: NotificationDestinationState, opts?: CustomResourceOptions): NotificationDestination

@staticmethod
def get(resource_name: str,
        id: str,
        opts: Optional[ResourceOptions] = None,
        auth: Optional[Mapping[str, str]] = None,
        name: Optional[str] = None,
        properties: Optional[Sequence[NotificationDestinationPropertyArgs]] = None,
        type: Optional[str] = None) -> NotificationDestination

func GetNotificationDestination(ctx *Context, name string, id IDInput, state *NotificationDestinationState, opts ...ResourceOption) (*NotificationDestination, error)

public static NotificationDestination Get(string name, Input<string> id, NotificationDestinationState? state, CustomResourceOptions? opts = null)

public static NotificationDestination get(String name, Output<String> id, NotificationDestinationState state, CustomResourceOptions options)

resources:  _:    type: newrelic:NotificationDestination    get:      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:

Auth Dictionary<string, string>: A nested block that describes a notification destination authentication. Only one auth block is permitted per notification destination definition. See Nested auth blocks below for details.
Name string: The name of the destination.
Properties List<Pulumi.NewRelic.Inputs.NotificationDestinationProperty>: A nested block that describes a notification destination properties. Only one properties block is permitted per notification destination definition. See Nested properties blocks below for details.
Type string: The type of the auth. One of: TOKEN or BASIC.

Auth map[string]string: A nested block that describes a notification destination authentication. Only one auth block is permitted per notification destination definition. See Nested auth blocks below for details.
Name string: The name of the destination.
Properties []NotificationDestinationPropertyArgs: A nested block that describes a notification destination properties. Only one properties block is permitted per notification destination definition. See Nested properties blocks below for details.
Type string: The type of the auth. One of: TOKEN or BASIC.

auth Map<String,String>: A nested block that describes a notification destination authentication. Only one auth block is permitted per notification destination definition. See Nested auth blocks below for details.
name String: The name of the destination.
properties List<NotificationDestinationProperty>: A nested block that describes a notification destination properties. Only one properties block is permitted per notification destination definition. See Nested properties blocks below for details.
type String: The type of the auth. One of: TOKEN or BASIC.

auth {[key: string]: string}: A nested block that describes a notification destination authentication. Only one auth block is permitted per notification destination definition. See Nested auth blocks below for details.
name string: The name of the destination.
properties NotificationDestinationProperty[]: A nested block that describes a notification destination properties. Only one properties block is permitted per notification destination definition. See Nested properties blocks below for details.
type string: The type of the auth. One of: TOKEN or BASIC.

auth Mapping[str, str]: A nested block that describes a notification destination authentication. Only one auth block is permitted per notification destination definition. See Nested auth blocks below for details.
name str: The name of the destination.
properties Sequence[NotificationDestinationPropertyArgs]: A nested block that describes a notification destination properties. Only one properties block is permitted per notification destination definition. See Nested properties blocks below for details.
type str: The type of the auth. One of: TOKEN or BASIC.

auth Map<String>: A nested block that describes a notification destination authentication. Only one auth block is permitted per notification destination definition. See Nested auth blocks below for details.
name String: The name of the destination.
properties List<Property Map>: A nested block that describes a notification destination properties. Only one properties block is permitted per notification destination definition. See Nested properties blocks below for details.
type String: The type of the auth. One of: TOKEN or BASIC.

Supporting Types

NotificationDestinationProperty, NotificationDestinationPropertyArgs

Key string
Value string
DisplayValue string
Label string

Key string
Value string
DisplayValue string
Label string

key String
value String
displayValue String
label String

key string
value string
displayValue string
label string

key str
value str
display_value str
label str

key String
value String
displayValue String
label String

Package Details

Repository: New Relic pulumi/pulumi-newrelic
License: Apache-2.0
Notes: This Pulumi package is based on the newrelic Terraform Provider.

Viewing docs for New Relic v4.20.0 (Older version)
published on Monday, Mar 9, 2026 by Pulumi

Go to latest version

Schema (JSON)

pulumi/pulumi-newrelic

newrelic.NotificationDestination

On this page

On this page

Additional Examples

ServiceNow

Email

PagerDuty with service integration

PagerDuty with account integration

Example Usage

Create NotificationDestination Resource

Constructor syntax

Parameters

Constructor example

NotificationDestination Resource Properties

Inputs

Outputs

Look up Existing NotificationDestination Resource

Supporting Types

NotificationDestinationProperty, NotificationDestinationPropertyArgs

Package Details

On this page

On this page