Sign in Dashboard Get started
  1. Registry
  2. Packages
  3. Logfire
  4. API Docs
  5. Channel
Viewing docs for Logfire v0.1.21
published on Wednesday, Sep 9, 2026 by Pydantic
Schema (JSON)
pydantic/pulumi-logfire

logfire.Channel

logfire logo
Viewing docs for Logfire v0.1.21
published on Wednesday, Sep 9, 2026 by Pydantic
Schema (JSON)
pydantic/pulumi-logfire

    Manages a Logfire alert channel.

    Example Usage

    import * as pulumi from "@pulumi/pulumi";
import * as logfire from "@pydantic/pulumi-logfire";

const config = new pulumi.Config();
const pagerdutyRoutingKey = config.require("pagerdutyRoutingKey");
const example = new logfire.Channel("example", {
    active: true,
    config: [{
        type: "webhook",
        format: "auto",
        url: "https://example.com/logfire-webhook",
    }],
});
const pagerduty = new logfire.Channel("pagerduty", {
    active: true,
    config: [{
        type: "pagerduty",
        routingKey: pagerdutyRoutingKey,
        region: "us",
    }],
});
const slackApp = new logfire.Channel("slackApp", {
    active: true,
    config: [{
        type: "slack-integration",
        installId: "018f9a6a-1234-7890-abcd-ef0123456789",
        channelId: "C0123456789",
    }],
});
const onCall = logfire.getPagerdutyService({
    accountSubdomain: "acme",
    region: "us",
    pagerdutyServiceId: "PABC123",
});
const pagerdutyApp = new logfire.Channel("pagerdutyApp", {
    active: true,
    config: [{
        type: "pagerduty-integration",
        installId: onCall.then(onCall => onCall.installId),
        serviceId: onCall.then(onCall => onCall.serviceId),
    }],
});

    import pulumi
import pulumi_logfire as logfire

config = pulumi.Config()
pagerduty_routing_key = config.require("pagerdutyRoutingKey")
example = logfire.Channel("example",
    active=True,
    config=[{
        "type": "webhook",
        "format": "auto",
        "url": "https://example.com/logfire-webhook",
    }])
pagerduty = logfire.Channel("pagerduty",
    active=True,
    config=[{
        "type": "pagerduty",
        "routingKey": pagerduty_routing_key,
        "region": "us",
    }])
slack_app = logfire.Channel("slackApp",
    active=True,
    config=[{
        "type": "slack-integration",
        "installId": "018f9a6a-1234-7890-abcd-ef0123456789",
        "channelId": "C0123456789",
    }])
on_call = logfire.get_pagerduty_service(account_subdomain="acme",
    region="us",
    pagerduty_service_id="PABC123")
pagerduty_app = logfire.Channel("pagerdutyApp",
    active=True,
    config=[{
        "type": "pagerduty-integration",
        "installId": on_call.install_id,
        "serviceId": on_call.service_id,
    }])

    package main

import (
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi/config"
	"github.com/pydantic/pulumi-logfire/sdk/go/logfire"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		cfg := config.New(ctx, "")
		pagerdutyRoutingKey := cfg.Require("pagerdutyRoutingKey")
		_, err := logfire.NewChannel(ctx, "example", &logfire.ChannelArgs{
			Active: pulumi.Bool(true),
			Config: logfire.ChannelConfigArgs{
				map[string]interface{}{
					"type":   "webhook",
					"format": "auto",
					"url":    "https://example.com/logfire-webhook",
				},
			},
		})
		if err != nil {
			return err
		}
		_, err = logfire.NewChannel(ctx, "pagerduty", &logfire.ChannelArgs{
			Active: pulumi.Bool(true),
			Config: logfire.ChannelConfigArgs{
				map[string]interface{}{
					"type":       "pagerduty",
					"routingKey": pagerdutyRoutingKey,
					"region":     "us",
				},
			},
		})
		if err != nil {
			return err
		}
		_, err = logfire.NewChannel(ctx, "slackApp", &logfire.ChannelArgs{
			Active: pulumi.Bool(true),
			Config: logfire.ChannelConfigArgs{
				map[string]interface{}{
					"type":      "slack-integration",
					"installId": "018f9a6a-1234-7890-abcd-ef0123456789",
					"channelId": "C0123456789",
				},
			},
		})
		if err != nil {
			return err
		}
		onCall, err := logfire.GetPagerdutyService(ctx, &logfire.GetPagerdutyServiceArgs{
			AccountSubdomain:   "acme",
			Region:             pulumi.StringRef("us"),
			PagerdutyServiceId: "PABC123",
		}, nil)
		if err != nil {
			return err
		}
		_, err = logfire.NewChannel(ctx, "pagerdutyApp", &logfire.ChannelArgs{
			Active: pulumi.Bool(true),
			Config: logfire.ChannelConfigArgs{
				map[string]interface{}{
					"type":      "pagerduty-integration",
					"installId": onCall.InstallId,
					"serviceId": onCall.ServiceId,
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var config = new Config();
    var pagerdutyRoutingKey = config.Require("pagerdutyRoutingKey");
    var example = new Logfire.Channel("example", new()
    {
        Active = true,
        Config = new[]
        {
            
            {
                { "type", "webhook" },
                { "format", "auto" },
                { "url", "https://example.com/logfire-webhook" },
            },
        },
    });

    var pagerduty = new Logfire.Channel("pagerduty", new()
    {
        Active = true,
        Config = new[]
        {
            
            {
                { "type", "pagerduty" },
                { "routingKey", pagerdutyRoutingKey },
                { "region", "us" },
            },
        },
    });

    var slackApp = new Logfire.Channel("slackApp", new()
    {
        Active = true,
        Config = new[]
        {
            
            {
                { "type", "slack-integration" },
                { "installId", "018f9a6a-1234-7890-abcd-ef0123456789" },
                { "channelId", "C0123456789" },
            },
        },
    });

    var onCall = Logfire.GetPagerdutyService.Invoke(new()
    {
        AccountSubdomain = "acme",
        Region = "us",
        PagerdutyServiceId = "PABC123",
    });

    var pagerdutyApp = new Logfire.Channel("pagerdutyApp", new()
    {
        Active = true,
        Config = new[]
        {
            
            {
                { "type", "pagerduty-integration" },
                { "installId", onCall.Apply(getPagerdutyServiceResult => getPagerdutyServiceResult.InstallId) },
                { "serviceId", onCall.Apply(getPagerdutyServiceResult => getPagerdutyServiceResult.ServiceId) },
            },
        },
    });

});

    package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.logfire.Channel;
import com.pulumi.logfire.ChannelArgs;
import com.pulumi.logfire.LogfireFunctions;
import com.pulumi.logfire.inputs.GetPagerdutyServiceArgs;
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) {
        final var config = ctx.config();
        final var pagerdutyRoutingKey = config.get("pagerdutyRoutingKey");
        var example = new Channel("example", ChannelArgs.builder()
            .active(true)
            .config(ChannelConfigArgs.builder()
                .type("webhook")
                .format("auto")
                .url("https://example.com/logfire-webhook")
                .build())
            .build());

        var pagerduty = new Channel("pagerduty", ChannelArgs.builder()
            .active(true)
            .config(ChannelConfigArgs.builder()
                .type("pagerduty")
                .routingKey(pagerdutyRoutingKey)
                .region("us")
                .build())
            .build());

        var slackApp = new Channel("slackApp", ChannelArgs.builder()
            .active(true)
            .config(ChannelConfigArgs.builder()
                .type("slack-integration")
                .installId("018f9a6a-1234-7890-abcd-ef0123456789")
                .channelId("C0123456789")
                .build())
            .build());

        final var onCall = LogfireFunctions.getPagerdutyService(GetPagerdutyServiceArgs.builder()
            .accountSubdomain("acme")
            .region("us")
            .pagerdutyServiceId("PABC123")
            .build());

        var pagerdutyApp = new Channel("pagerdutyApp", ChannelArgs.builder()
            .active(true)
            .config(ChannelConfigArgs.builder()
                .type("pagerduty-integration")
                .installId(onCall.installId())
                .serviceId(onCall.serviceId())
                .build())
            .build());

    }
}

    configuration:
  pagerdutyRoutingKey:
    type: string
resources:
  example:
    type: logfire:Channel
    properties:
      active: true
      config:
        - type: webhook
          format: auto
          url: https://example.com/logfire-webhook
  pagerduty:
    type: logfire:Channel
    properties:
      active: true
      config:
        - type: pagerduty
          routingKey: ${pagerdutyRoutingKey}
          region: us
  slackApp:
    type: logfire:Channel
    properties:
      active: true
      config:
        - type: slack-integration
          installId: 018f9a6a-1234-7890-abcd-ef0123456789
          channelId: C0123456789
  pagerdutyApp:
    type: logfire:Channel
    properties:
      active: true
      config:
        - type: pagerduty-integration
          installId: ${onCall.installId}
          serviceId: ${onCall.serviceId}
variables:
  onCall:
    fn::invoke:
      function: logfire:getPagerdutyService
      arguments:
        accountSubdomain: acme
        region: us
        pagerdutyServiceId: PABC123

    Example coming soon!

    Create Channel Resource

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

    Constructor syntax

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

@overload
def Channel(resource_name: str,
            opts: Optional[ResourceOptions] = None,
            active: Optional[bool] = None,
            config: Optional[ChannelConfigArgs] = None,
            name: Optional[str] = None)
    func NewChannel(ctx *Context, name string, args *ChannelArgs, opts ...ResourceOption) (*Channel, error)
    public Channel(string name, ChannelArgs? args = null, CustomResourceOptions? opts = null)
    public Channel(String name, ChannelArgs args)
public Channel(String name, ChannelArgs args, CustomResourceOptions options)

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


    resource "logfire_channel" "name" {
    # resource properties
}

    Parameters

    name string
    The unique name of the resource.
    args ChannelArgs
    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 ChannelArgs
    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 ChannelArgs
    The arguments to resource properties.
    opts ResourceOption
    Bag of options to control resource's behavior.
    name string
    The unique name of the resource.
    args ChannelArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    name String
    The unique name of the resource.
    args ChannelArgs
    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 channelResource = new Logfire.Channel("channelResource", new()
{
    Active = false,
    Config = new Logfire.Inputs.ChannelConfigArgs
    {
        Type = "string",
        AuthKey = "string",
        ChannelId = "string",
        Format = "string",
        IncludeAgentPrompt = false,
        InstallId = "string",
        Region = "string",
        RoutingKey = "string",
        ServiceId = "string",
        Url = "string",
    },
    Name = "string",
});

    example, err := logfire.NewChannel(ctx, "channelResource", &logfire.ChannelArgs{
	Active: pulumi.Bool(false),
	Config: &logfire.ChannelConfigArgs{
		Type:               pulumi.String("string"),
		AuthKey:            pulumi.String("string"),
		ChannelId:          pulumi.String("string"),
		Format:             pulumi.String("string"),
		IncludeAgentPrompt: pulumi.Bool(false),
		InstallId:          pulumi.String("string"),
		Region:             pulumi.String("string"),
		RoutingKey:         pulumi.String("string"),
		ServiceId:          pulumi.String("string"),
		Url:                pulumi.String("string"),
	},
	Name: pulumi.String("string"),
})

    resource "logfire_channel" "channelResource" {
  lifecycle {
    create_before_destroy = true
  }
  active = false
  config = {
    type                 = "string"
    auth_key             = "string"
    channel_id           = "string"
    format               = "string"
    include_agent_prompt = false
    install_id           = "string"
    region               = "string"
    routing_key          = "string"
    service_id           = "string"
    url                  = "string"
  }
  name = "string"
}

    var channelResource = new Channel("channelResource", ChannelArgs.builder()
    .active(false)
    .config(ChannelConfigArgs.builder()
        .type("string")
        .authKey("string")
        .channelId("string")
        .format("string")
        .includeAgentPrompt(false)
        .installId("string")
        .region("string")
        .routingKey("string")
        .serviceId("string")
        .url("string")
        .build())
    .name("string")
    .build());

    channel_resource = logfire.Channel("channelResource",
    active=False,
    config={
        "type": "string",
        "auth_key": "string",
        "channel_id": "string",
        "format": "string",
        "include_agent_prompt": False,
        "install_id": "string",
        "region": "string",
        "routing_key": "string",
        "service_id": "string",
        "url": "string",
    },
    name="string")

    const channelResource = new logfire.Channel("channelResource", {
    active: false,
    config: {
        type: "string",
        authKey: "string",
        channelId: "string",
        format: "string",
        includeAgentPrompt: false,
        installId: "string",
        region: "string",
        routingKey: "string",
        serviceId: "string",
        url: "string",
    },
    name: "string",
});

    type: logfire:Channel
properties:
    active: false
    config:
        authKey: string
        channelId: string
        format: string
        includeAgentPrompt: false
        installId: string
        region: string
        routingKey: string
        serviceId: string
        type: string
        url: string
    name: string

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

    Active bool
    Whether the channel is active.
    Config ChannelConfig
    Required channel configuration.
    Name string
    Channel name.
    Active bool
    Whether the channel is active.
    Config ChannelConfigArgs
    Required channel configuration.
    Name string
    Channel name.
    active bool
    Whether the channel is active.
    config object
    Required channel configuration.
    name string
    Channel name.
    active Boolean
    Whether the channel is active.
    config ChannelConfig
    Required channel configuration.
    name String
    Channel name.
    active boolean
    Whether the channel is active.
    config ChannelConfig
    Required channel configuration.
    name string
    Channel name.
    active bool
    Whether the channel is active.
    config ChannelConfigArgs
    Required channel configuration.
    name str
    Channel name.
    active Boolean
    Whether the channel is active.
    config Property Map
    Required channel configuration.
    name String
    Channel name.

    Outputs

    All input properties are implicitly available as output properties. Additionally, the Channel 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 Channel Resource

    Get an existing Channel 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?: ChannelState, opts?: CustomResourceOptions): Channel
    @staticmethod
def get(resource_name: str,
        id: str,
        opts: Optional[ResourceOptions] = None,
        active: Optional[bool] = None,
        config: Optional[ChannelConfigArgs] = None,
        name: Optional[str] = None) -> Channel
    func GetChannel(ctx *Context, name string, id IDInput, state *ChannelState, opts ...ResourceOption) (*Channel, error)
    public static Channel Get(string name, Input<string> id, ChannelState? state, CustomResourceOptions? opts = null)
    public static Channel get(String name, Output<String> id, ChannelState state, CustomResourceOptions options)
    resources:  _:    type: logfire:Channel    get:      id: ${id}
    import {
  to = logfire_channel.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:
    Active bool
    Whether the channel is active.
    Config ChannelConfig
    Required channel configuration.
    Name string
    Channel name.
    Active bool
    Whether the channel is active.
    Config ChannelConfigArgs
    Required channel configuration.
    Name string
    Channel name.
    active bool
    Whether the channel is active.
    config object
    Required channel configuration.
    name string
    Channel name.
    active Boolean
    Whether the channel is active.
    config ChannelConfig
    Required channel configuration.
    name String
    Channel name.
    active boolean
    Whether the channel is active.
    config ChannelConfig
    Required channel configuration.
    name string
    Channel name.
    active bool
    Whether the channel is active.
    config ChannelConfigArgs
    Required channel configuration.
    name str
    Channel name.
    active Boolean
    Whether the channel is active.
    config Property Map
    Required channel configuration.
    name String
    Channel name.

    Supporting Types

    ChannelConfig, ChannelConfigArgs

    Type string
    Channel type (webhook, opsgenie, pagerduty, pagerduty-integration, or slack-integration).
    AuthKey string
    Opsgenie API key.
    ChannelId string
    Slack channel ID (for example C0123456789) the notifications are posted to. The Logfire Slack bot must already be a member of the channel.
    Format string
    Webhook payload format.
    IncludeAgentPrompt bool
    Whether Slack issue notifications include the "Ask your agent" MCP prompt line. Defaults to true when omitted.
    InstallId string
    ID of the organization's Slack App or PagerDuty App installation, created by connecting the platform in the Logfire UI (Organization Settings > Connections). The installation must belong to the same organization, be active, and match the channel type.
    Region string
    PagerDuty account region (us or eu). When omitted, Logfire uses the US Events API endpoint. Only for pagerduty channels; a pagerduty-integration channel takes its region from the connected account.
    RoutingKey string
    PagerDuty Events API v2 integration routing key. Only for pagerduty channels; pagerduty-integration channels resolve the key from the installation instead.
    ServiceId string
    Logfire's ID (a UUID) for the PagerDuty service incidents are opened on, as approved for the installation when connecting PagerDuty. This is not PagerDuty's own service ID. Required for pagerduty-integration channels.
    Url string
    Webhook URL endpoint.
    Type string
    Channel type (webhook, opsgenie, pagerduty, pagerduty-integration, or slack-integration).
    AuthKey string
    Opsgenie API key.
    ChannelId string
    Slack channel ID (for example C0123456789) the notifications are posted to. The Logfire Slack bot must already be a member of the channel.
    Format string
    Webhook payload format.
    IncludeAgentPrompt bool
    Whether Slack issue notifications include the "Ask your agent" MCP prompt line. Defaults to true when omitted.
    InstallId string
    ID of the organization's Slack App or PagerDuty App installation, created by connecting the platform in the Logfire UI (Organization Settings > Connections). The installation must belong to the same organization, be active, and match the channel type.
    Region string
    PagerDuty account region (us or eu). When omitted, Logfire uses the US Events API endpoint. Only for pagerduty channels; a pagerduty-integration channel takes its region from the connected account.
    RoutingKey string
    PagerDuty Events API v2 integration routing key. Only for pagerduty channels; pagerduty-integration channels resolve the key from the installation instead.
    ServiceId string
    Logfire's ID (a UUID) for the PagerDuty service incidents are opened on, as approved for the installation when connecting PagerDuty. This is not PagerDuty's own service ID. Required for pagerduty-integration channels.
    Url string
    Webhook URL endpoint.
    type string
    Channel type (webhook, opsgenie, pagerduty, pagerduty-integration, or slack-integration).
    auth_key string
    Opsgenie API key.
    channel_id string
    Slack channel ID (for example C0123456789) the notifications are posted to. The Logfire Slack bot must already be a member of the channel.
    format string
    Webhook payload format.
    include_agent_prompt bool
    Whether Slack issue notifications include the "Ask your agent" MCP prompt line. Defaults to true when omitted.
    install_id string
    ID of the organization's Slack App or PagerDuty App installation, created by connecting the platform in the Logfire UI (Organization Settings > Connections). The installation must belong to the same organization, be active, and match the channel type.
    region string
    PagerDuty account region (us or eu). When omitted, Logfire uses the US Events API endpoint. Only for pagerduty channels; a pagerduty-integration channel takes its region from the connected account.
    routing_key string
    PagerDuty Events API v2 integration routing key. Only for pagerduty channels; pagerduty-integration channels resolve the key from the installation instead.
    service_id string
    Logfire's ID (a UUID) for the PagerDuty service incidents are opened on, as approved for the installation when connecting PagerDuty. This is not PagerDuty's own service ID. Required for pagerduty-integration channels.
    url string
    Webhook URL endpoint.
    type String
    Channel type (webhook, opsgenie, pagerduty, pagerduty-integration, or slack-integration).
    authKey String
    Opsgenie API key.
    channelId String
    Slack channel ID (for example C0123456789) the notifications are posted to. The Logfire Slack bot must already be a member of the channel.
    format String
    Webhook payload format.
    includeAgentPrompt Boolean
    Whether Slack issue notifications include the "Ask your agent" MCP prompt line. Defaults to true when omitted.
    installId String
    ID of the organization's Slack App or PagerDuty App installation, created by connecting the platform in the Logfire UI (Organization Settings > Connections). The installation must belong to the same organization, be active, and match the channel type.
    region String
    PagerDuty account region (us or eu). When omitted, Logfire uses the US Events API endpoint. Only for pagerduty channels; a pagerduty-integration channel takes its region from the connected account.
    routingKey String
    PagerDuty Events API v2 integration routing key. Only for pagerduty channels; pagerduty-integration channels resolve the key from the installation instead.
    serviceId String
    Logfire's ID (a UUID) for the PagerDuty service incidents are opened on, as approved for the installation when connecting PagerDuty. This is not PagerDuty's own service ID. Required for pagerduty-integration channels.
    url String
    Webhook URL endpoint.
    type string
    Channel type (webhook, opsgenie, pagerduty, pagerduty-integration, or slack-integration).
    authKey string
    Opsgenie API key.
    channelId string
    Slack channel ID (for example C0123456789) the notifications are posted to. The Logfire Slack bot must already be a member of the channel.
    format string
    Webhook payload format.
    includeAgentPrompt boolean
    Whether Slack issue notifications include the "Ask your agent" MCP prompt line. Defaults to true when omitted.
    installId string
    ID of the organization's Slack App or PagerDuty App installation, created by connecting the platform in the Logfire UI (Organization Settings > Connections). The installation must belong to the same organization, be active, and match the channel type.
    region string
    PagerDuty account region (us or eu). When omitted, Logfire uses the US Events API endpoint. Only for pagerduty channels; a pagerduty-integration channel takes its region from the connected account.
    routingKey string
    PagerDuty Events API v2 integration routing key. Only for pagerduty channels; pagerduty-integration channels resolve the key from the installation instead.
    serviceId string
    Logfire's ID (a UUID) for the PagerDuty service incidents are opened on, as approved for the installation when connecting PagerDuty. This is not PagerDuty's own service ID. Required for pagerduty-integration channels.
    url string
    Webhook URL endpoint.
    type str
    Channel type (webhook, opsgenie, pagerduty, pagerduty-integration, or slack-integration).
    auth_key str
    Opsgenie API key.
    channel_id str
    Slack channel ID (for example C0123456789) the notifications are posted to. The Logfire Slack bot must already be a member of the channel.
    format str
    Webhook payload format.
    include_agent_prompt bool
    Whether Slack issue notifications include the "Ask your agent" MCP prompt line. Defaults to true when omitted.
    install_id str
    ID of the organization's Slack App or PagerDuty App installation, created by connecting the platform in the Logfire UI (Organization Settings > Connections). The installation must belong to the same organization, be active, and match the channel type.
    region str
    PagerDuty account region (us or eu). When omitted, Logfire uses the US Events API endpoint. Only for pagerduty channels; a pagerduty-integration channel takes its region from the connected account.
    routing_key str
    PagerDuty Events API v2 integration routing key. Only for pagerduty channels; pagerduty-integration channels resolve the key from the installation instead.
    service_id str
    Logfire's ID (a UUID) for the PagerDuty service incidents are opened on, as approved for the installation when connecting PagerDuty. This is not PagerDuty's own service ID. Required for pagerduty-integration channels.
    url str
    Webhook URL endpoint.
    type String
    Channel type (webhook, opsgenie, pagerduty, pagerduty-integration, or slack-integration).
    authKey String
    Opsgenie API key.
    channelId String
    Slack channel ID (for example C0123456789) the notifications are posted to. The Logfire Slack bot must already be a member of the channel.
    format String
    Webhook payload format.
    includeAgentPrompt Boolean
    Whether Slack issue notifications include the "Ask your agent" MCP prompt line. Defaults to true when omitted.
    installId String
    ID of the organization's Slack App or PagerDuty App installation, created by connecting the platform in the Logfire UI (Organization Settings > Connections). The installation must belong to the same organization, be active, and match the channel type.
    region String
    PagerDuty account region (us or eu). When omitted, Logfire uses the US Events API endpoint. Only for pagerduty channels; a pagerduty-integration channel takes its region from the connected account.
    routingKey String
    PagerDuty Events API v2 integration routing key. Only for pagerduty channels; pagerduty-integration channels resolve the key from the installation instead.
    serviceId String
    Logfire's ID (a UUID) for the PagerDuty service incidents are opened on, as approved for the installation when connecting PagerDuty. This is not PagerDuty's own service ID. Required for pagerduty-integration channels.
    url String
    Webhook URL endpoint.

    Package Details

    Repository
    logfire pydantic/pulumi-logfire
    License
    Apache-2.0
    Notes
    This Pulumi package is based on the logfire Terraform Provider.
    logfire logo
    Viewing docs for Logfire v0.1.21
    published on Wednesday, Sep 9, 2026 by Pydantic
    Schema (JSON)
    pydantic/pulumi-logfire

      Try Pulumi Cloud free.
      Your team will thank you.

      Start free trial