> ## Documentation Index
> Fetch the complete documentation index at: https://docs.barndoor.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# List the caller's personal channels

> Returns the authenticated caller's own `in_app` and `user_email` channels. Always self-scoped — there is no way to read another user's personal channels, and no user parameter to pass.



## OpenAPI

````yaml /api-reference/openapi.yaml get /api/notification/public/v1/channels/user
openapi: 3.1.0
info:
  title: Barndoor.ai Public API
  description: Unified public API specification for Barndoor.ai platform
  version: 2.18.0
servers:
  - url: https://{host}
    description: Barndoor public API
    variables:
      host:
        default: platform.barndoor.ai
        description: >-
          The host serving your Barndoor deployment. Defaults to production;
          override it for another environment or a dedicated deployment.
security:
  - ApiKey: []
  - OAuth2:
      - openid
      - profile
      - email
tags:
  - name: dlp
    x-group: Data Control Center
  - name: identity
    x-group: Identity
  - name: llm-gateway
    x-group: LLM Gateway
  - name: notification
    x-group: Notifications
  - name: policy
    x-group: Policies
  - name: registry
    x-group: MCP Gateway
  - name: system-management
    x-group: Log Exports
paths:
  /api/notification/public/v1/channels/user:
    get:
      tags:
        - notification
      summary: List the caller's personal channels
      description: >-
        Returns the authenticated caller's own `in_app` and `user_email`
        channels. Always self-scoped — there is no way to read another user's
        personal channels, and no user parameter to pass.
      operationId: get_my_alert_channel
      responses:
        '200':
          description: Successful Response
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ChannelListResponse'
        '401':
          description: Missing, malformed, or expired bearer token.
        '403':
          description: Authenticated, but not permitted to manage this channel.
components:
  schemas:
    ChannelListResponse:
      properties:
        data:
          items:
            $ref: '#/components/schemas/ChannelResponse'
          type: array
          title: Data
          description: The channels, in no guaranteed order.
      type: object
      required:
        - data
      title: ChannelListResponse
      description: >-
        A page-less list of channels. Unpaginated by design — the number of
        channels an

        organization has is small and bounded by hand-configuration.
    ChannelResponse:
      properties:
        id:
          type: string
          format: uuid
          title: Id
          description: >-
            Server-assigned channel id. Stable across updates; pass it as `id`
            to edit by id.
        type:
          $ref: '#/components/schemas/ChannelType'
          description: The kind of destination. See `ChannelType`.
        enabled:
          type: boolean
          title: Enabled
          description: Whether the channel currently delivers.
        user_id:
          anyOf:
            - type: string
              format: uuid
            - type: 'null'
          title: User Id
          description: >-
            Owning user for a personal channel (`in_app`, `user_email`). `null`
            for the org-wide types, which belong to the organization rather than
            one user.
        email_address:
          anyOf:
            - type: string
            - type: 'null'
          title: Email Address
          description: >-
            Destination address for `type: email`, normalized. `null` for every
            other type.
        url:
          anyOf:
            - type: string
            - type: 'null'
          title: Url
          description: >-
            Destination endpoint for `type: webhook`. `null` for every other
            type.
        label:
          anyOf:
            - type: string
            - type: 'null'
          title: Label
          description: >-
            Human-readable name, set for `slack` and `teams`. `null` for the
            other types.
        slack_channel_id:
          anyOf:
            - type: string
            - type: 'null'
          title: Slack Channel Id
          description: 'Slack channel id for `type: slack`. `null` for every other type.'
        subscriptions:
          items:
            $ref: '#/components/schemas/ChannelSubscription'
          type: array
          title: Subscriptions
          description: >-
            The alert types this channel currently delivers. Empty means it
            delivers nothing.
        created_at:
          type: string
          format: date-time
          title: Created At
          description: When the channel was created (UTC).
        updated_at:
          type: string
          format: date-time
          title: Updated At
          description: When the channel or its subscriptions last changed (UTC).
        has_signing_secret:
          type: boolean
          title: Has Signing Secret
          description: >-
            Whether a `webhook` channel has a stored signing secret — always
            true for a webhook channel, false otherwise. The secret itself is
            never readable back; use `POST
            /channels/{channel_id}/regenerate-secret` to obtain a fresh one.
          default: false
        has_workflow_url:
          type: boolean
          title: Has Workflow Url
          description: >-
            Whether a `teams` channel has a stored Workflows URL. The URL is a
            secret and is never returned; this flag is the only readable signal
            that one is configured.
          default: false
        signing_secret:
          anyOf:
            - type: string
            - type: 'null'
          title: Signing Secret
          description: >-
            One-time reveal of a newly generated webhook signing secret. Present
            **only** on the response to the request that created it — the `PUT`
            that first creates a `webhook` channel — and `null` on every list or
            subsequent read. Store it when you receive it; the only way to
            recover from losing it is to rotate.
      type: object
      required:
        - id
        - type
        - enabled
        - user_id
        - email_address
        - url
        - label
        - slack_channel_id
        - subscriptions
        - created_at
        - updated_at
      title: ChannelResponse
      description: >-
        A channel and its subscriptions. Secrets (webhook signing secret, slack
        bot token) live

        in OpenBao and are never surfaced here except as a one-time reveal via
        ``signing_secret``,

        populated only on the response to the request that just generated it
        (webhook create or

        regenerate); slack channels expose only the non-secret ``label`` +
        ``slack_channel_id``.
    ChannelType:
      type: string
      enum:
        - in_app
        - user_email
        - email
        - webhook
        - slack
        - teams
      title: ChannelType
      description: >-
        What kind of destination a channel delivers to. The type is the
        discriminator for the

        whole channel model: it decides which destination field is required,
        whether the channel is

        personal (owned by one user) or org-wide (managed by an admin), and
        which natural-identity

        key an upsert without ``id`` dedupes on.


        Personal — owner is always the authenticated caller, never taken from
        the request body:


        - ``in_app``: the caller's notification inbox in the platform UI. No
        destination field.

        - ``user_email``: the caller's own verified account email. No
        destination field.


        Org-wide — admin/superadmin managed, one set per organization:


        - ``email``: an arbitrary address (a team alias, a ticketing inbox).
        Requires
          ``email_address``; deduped on it.
        - ``webhook``: an HTTPS endpoint you own, signed with a Standard
        Webhooks
          ``whsec_`` secret. Requires ``url``; deduped on it.
        - ``slack``: a channel in the organization's connected Slack workspace.
        Requires
          ``slack_channel_id`` + ``label``; needs the Slack app installed first (an interactive
          consent flow that is not part of this API).
        - ``teams``: a Microsoft Teams channel behind a Workflows
        incoming-webhook URL. Requires
          ``label``, plus ``teams_workflow_url`` on create.
    ChannelSubscription:
      properties:
        alert_type:
          $ref: '#/components/schemas/AlertType'
          description: The subscribed alert type.
      type: object
      required:
        - alert_type
      title: ChannelSubscription
      description: One alert type this channel is subscribed to.
    AlertType:
      type: string
      enum:
        - llm_threshold_exceeded
        - connection_broken
        - mcp_server_added
        - mcp_server_deleted
        - policy_changed
        - policy_impact
        - admin_role_change
        - break_glass_used
        - llm_budget_exhausted
        - llm_provider_unavailable
        - llm_provider_key_rejected
        - api_key_revoked
        - llm_api_key_expiring
        - llm_api_key_expired
        - mcp_server_tooling_changed
      title: AlertType
      description: >-
        A discrete, notification-worthy event. This is what publishers emit and
        what channels

        subscribe to — a channel is delivered an alert when its subscription set
        contains that

        alert's type. Severity and category are intrinsic to the type (see
        ``ALERT_TAXONOMY``), so

        they are never set per subscription.


        Treat this enum as open: values are added over time, and the set your
        organization may

        actually subscribe to is gated by feature flags. Read

        ``GET /public/v1/channels/options`` for the live vocabulary rather than
        hardcoding these

        names — subscribing to a type your organization is not admitted to is
        silently inert.
  securitySchemes:
    ApiKey:
      type: http
      scheme: bearer
      description: >-
        A Barndoor API key, sent as `Authorization: Bearer <key>`. Keys are
        prefixed `bdai_` and are opaque — do not attempt to decode one.
        Interchangeable with an OAuth 2.0 access token.
    OAuth2:
      type: oauth2
      x-issuer: https://auth.barndoor.ai/realms/barndoor
      description: >-
        An OAuth 2.0 access token from Barndoor's identity provider, sent as
        `Authorization: Bearer <token>`. Public clients must use PKCE.
        Interchangeable with an API key.
      flows:
        authorizationCode:
          authorizationUrl: >-
            https://auth.barndoor.ai/realms/barndoor/protocol/openid-connect/auth
          tokenUrl: >-
            https://auth.barndoor.ai/realms/barndoor/protocol/openid-connect/token
          scopes:
            openid: Issue an OIDC ID token identifying the caller.
            profile: Read the caller's basic profile claims.
            email: Read the caller's email address.
            offline_access: Issue a refresh token. Optional — no operation requires it.
        clientCredentials:
          tokenUrl: >-
            https://auth.barndoor.ai/realms/barndoor/protocol/openid-connect/token
          scopes:
            openid: Issue an OIDC ID token identifying the caller.
            profile: Read the caller's basic profile claims.
            email: Read the caller's email address.
            offline_access: Issue a refresh token. Optional — no operation requires it.

````

This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.