Create a channel endpoint

POST

channel-endpoints

Csharp (SDK)

using Novu;
using Novu.Models.Components;
using Novu.Models.Requests;

var sdk = new NovuSDK(secretKey: "YOUR_SECRET_KEY_HERE");

var res = await sdk.ChannelEndpoints.CreateAsync(requestBody: ChannelEndpointsControllerCreateChannelEndpointRequestBody.CreateSlackChannel(
    new CreateSlackChannelEndpointDto() {
        SubscriberId = "subscriber-123",
        IntegrationIdentifier = "slack-prod",
        Type = CreateSlackChannelEndpointDtoType.SlackChannel,
        Endpoint = new SlackChannelEndpointDto() {
            ChannelId = "C123456789",
        },
    }
));

// handle response

declare(strict_types=1);

require 'vendor/autoload.php';

use novu;
use novu\Models\Components;

$sdk = novu\Novu::builder()
    ->setSecurity(
        'YOUR_SECRET_KEY_HERE'
    )
    ->build();



$response = $sdk->channelEndpoints->create(
    requestBody: new Components\CreateSlackChannelEndpointDto(
        subscriberId: 'subscriber-123',
        integrationIdentifier: 'slack-prod',
        type: Components\CreateSlackChannelEndpointDtoType::SlackChannel,
        endpoint: new Components\SlackChannelEndpointDto(
            channelId: 'C123456789',
        ),
    )
);

if ($response->getChannelEndpointResponseDto !== null) {
    // handle response
}

import novu_py
from novu_py import Novu


with Novu(
    secret_key="YOUR_SECRET_KEY_HERE",
) as novu:

    res = novu.channel_endpoints.create(request_body={
        "subscriber_id": "subscriber-123",
        "create_subscriber_if_missing": False,
        "integration_identifier": "slack-prod",
        "type": novu_py.CreateSlackChannelEndpointDtoType.SLACK_CHANNEL,
        "endpoint": {
            "channel_id": "C123456789",
        },
    })

    # Handle response
    print(res)

package main

import(
	"context"
	"github.com/novuhq/novu-go/v3"
	"github.com/novuhq/novu-go/v3/models/components"
	"github.com/novuhq/novu-go/v3/models/operations"
	"log"
)

func main() {
    ctx := context.Background()

    s := v3.New(
        v3.WithSecurity("YOUR_SECRET_KEY_HERE"),
    )

    res, err := s.ChannelEndpoints.Create(ctx, operations.CreateChannelEndpointsControllerCreateChannelEndpointRequestBodySlackChannel(
        components.CreateSlackChannelEndpointDto{
            SubscriberID: "subscriber-123",
            IntegrationIdentifier: "slack-prod",
            Type: components.CreateSlackChannelEndpointDtoTypeSlackChannel,
            Endpoint: components.SlackChannelEndpointDto{
                ChannelID: "C123456789",
            },
        },
    ), nil)
    if err != nil {
        log.Fatal(err)
    }
    if res.GetChannelEndpointResponseDto != nil {
        switch res.GetChannelEndpointResponseDto.Endpoint.Type {
            case components.EndpointTypeSlackChannelEndpointDto:
                // res.GetChannelEndpointResponseDto.Endpoint.SlackChannelEndpointDto is populated
            case components.EndpointTypeSlackUserEndpointDto:
                // res.GetChannelEndpointResponseDto.Endpoint.SlackUserEndpointDto is populated
            case components.EndpointTypeWebhookEndpointDto:
                // res.GetChannelEndpointResponseDto.Endpoint.WebhookEndpointDto is populated
            case components.EndpointTypePhoneEndpointDto:
                // res.GetChannelEndpointResponseDto.Endpoint.PhoneEndpointDto is populated
            case components.EndpointTypeMsTeamsChannelEndpointDto:
                // res.GetChannelEndpointResponseDto.Endpoint.MsTeamsChannelEndpointDto is populated
            case components.EndpointTypeMsTeamsUserEndpointDto:
                // res.GetChannelEndpointResponseDto.Endpoint.MsTeamsUserEndpointDto is populated
            case components.EndpointTypeTelegramChatEndpointDto:
                // res.GetChannelEndpointResponseDto.Endpoint.TelegramChatEndpointDto is populated
            case components.EndpointTypeWebexRoomEndpointDto:
                // res.GetChannelEndpointResponseDto.Endpoint.WebexRoomEndpointDto is populated
            case components.EndpointTypeWebexPersonEndpointDto:
                // res.GetChannelEndpointResponseDto.Endpoint.WebexPersonEndpointDto is populated
            case components.EndpointTypeLineUserEndpointDto:
                // res.GetChannelEndpointResponseDto.Endpoint.LineUserEndpointDto is populated
            case components.EndpointTypePagerDutyServiceEndpointDto:
                // res.GetChannelEndpointResponseDto.Endpoint.PagerDutyServiceEndpointDto is populated
            case components.EndpointTypeOpsgenieIntegrationEndpointDto:
                // res.GetChannelEndpointResponseDto.Endpoint.OpsgenieIntegrationEndpointDto is populated
            case components.EndpointTypeGrafanaOnCallIntegrationEndpointDto:
                // res.GetChannelEndpointResponseDto.Endpoint.GrafanaOnCallIntegrationEndpointDto is populated
            case components.EndpointTypeToolWebhookEndpointDto:
                // res.GetChannelEndpointResponseDto.Endpoint.ToolWebhookEndpointDto is populated
        }

    }
}

import { Novu } from "@novu/api";

const novu = new Novu({
  secretKey: "YOUR_SECRET_KEY_HERE",
});

async function run() {
  const result = await novu.channelEndpoints.create({
    subscriberId: "subscriber-123",
    createSubscriberIfMissing: false,
    integrationIdentifier: "slack-prod",
    type: "slack_channel",
    endpoint: {
      channelId: "C123456789",
    },
  });

  console.log(result);
}

run();

curl --request POST \
  --url https://api.novu.co/v1/channel-endpoints \
  --header 'Authorization: <api-key>' \
  --header 'Content-Type: application/json' \
  --data '
{
  "subscriberId": "subscriber-123",
  "integrationIdentifier": "slack-prod",
  "type": "slack_channel",
  "endpoint": {
    "channelId": "C123456789"
  },
  "identifier": "slack-channel-user123-abc4",
  "createSubscriberIfMissing": false,
  "context": {},
  "connectionIdentifier": "slack-connection-abc123"
}
'

const options = {
  method: 'POST',
  headers: {Authorization: '<api-key>', 'Content-Type': 'application/json'},
  body: JSON.stringify({
    subscriberId: 'subscriber-123',
    integrationIdentifier: 'slack-prod',
    type: 'slack_channel',
    endpoint: {channelId: 'C123456789'},
    identifier: 'slack-channel-user123-abc4',
    createSubscriberIfMissing: false,
    context: {},
    connectionIdentifier: 'slack-connection-abc123'
  })
};

fetch('https://api.novu.co/v1/channel-endpoints', options)
  .then(res => res.json())
  .then(res => console.log(res))
  .catch(err => console.error(err));

HttpResponse<String> response = Unirest.post("https://api.novu.co/v1/channel-endpoints")
  .header("Authorization", "<api-key>")
  .header("Content-Type", "application/json")
  .body("{\n  \"subscriberId\": \"subscriber-123\",\n  \"integrationIdentifier\": \"slack-prod\",\n  \"type\": \"slack_channel\",\n  \"endpoint\": {\n    \"channelId\": \"C123456789\"\n  },\n  \"identifier\": \"slack-channel-user123-abc4\",\n  \"createSubscriberIfMissing\": false,\n  \"context\": {},\n  \"connectionIdentifier\": \"slack-connection-abc123\"\n}")
  .asString();

require 'uri'
require 'net/http'

url = URI("https://api.novu.co/v1/channel-endpoints")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["Authorization"] = '<api-key>'
request["Content-Type"] = 'application/json'
request.body = "{\n  \"subscriberId\": \"subscriber-123\",\n  \"integrationIdentifier\": \"slack-prod\",\n  \"type\": \"slack_channel\",\n  \"endpoint\": {\n    \"channelId\": \"C123456789\"\n  },\n  \"identifier\": \"slack-channel-user123-abc4\",\n  \"createSubscriberIfMissing\": false,\n  \"context\": {},\n  \"connectionIdentifier\": \"slack-connection-abc123\"\n}"

response = http.request(request)
puts response.read_body

{
  "identifier": "<string>",
  "channel": "in_app",
  "providerId": "slack",
  "integrationIdentifier": "slack-prod",
  "connectionIdentifier": "slack-connection-abc123",
  "subscriberId": "subscriber-123",
  "contextKeys": [
    "tenant:org-123",
    "region:us-east-1"
  ],
  "type": "slack_channel",
  "endpoint": {
    "channelId": "C123456789"
  },
  "createdAt": "<string>",
  "updatedAt": "<string>"
}

{
  "statusCode": 404,
  "timestamp": "2024-12-12T13:00:00Z",
  "path": "/api/v1/resource",
  "message": "xx xx xx ",
  "ctx": {
    "workflowId": "some_wf_id",
    "stepId": "some_wf_id"
  },
  "errorId": "abc123"
}

{
  "statusCode": 404,
  "timestamp": "2024-12-12T13:00:00Z",
  "path": "/api/v1/resource",
  "message": "xx xx xx ",
  "ctx": {
    "workflowId": "some_wf_id",
    "stepId": "some_wf_id"
  },
  "errorId": "abc123"
}

{
  "statusCode": 404,
  "timestamp": "2024-12-12T13:00:00Z",
  "path": "/api/v1/resource",
  "message": "xx xx xx ",
  "ctx": {
    "workflowId": "some_wf_id",
    "stepId": "some_wf_id"
  },
  "errorId": "abc123"
}

{
  "statusCode": 404,
  "timestamp": "2024-12-12T13:00:00Z",
  "path": "/api/v1/resource",
  "message": "xx xx xx ",
  "ctx": {
    "workflowId": "some_wf_id",
    "stepId": "some_wf_id"
  },
  "errorId": "abc123"
}

{
  "statusCode": 404,
  "timestamp": "2024-12-12T13:00:00Z",
  "path": "/api/v1/resource",
  "message": "xx xx xx ",
  "ctx": {
    "workflowId": "some_wf_id",
    "stepId": "some_wf_id"
  },
  "errorId": "abc123"
}

{
  "statusCode": 404,
  "timestamp": "2024-12-12T13:00:00Z",
  "path": "/api/v1/resource",
  "message": "xx xx xx ",
  "ctx": {
    "workflowId": "some_wf_id",
    "stepId": "some_wf_id"
  },
  "errorId": "abc123"
}

{
  "statusCode": 404,
  "timestamp": "2024-12-12T13:00:00Z",
  "path": "/api/v1/resource",
  "message": "xx xx xx ",
  "ctx": {
    "workflowId": "some_wf_id",
    "stepId": "some_wf_id"
  },
  "errorId": "abc123"
}

{
  "statusCode": 404,
  "timestamp": "2024-12-12T13:00:00Z",
  "path": "/api/v1/resource",
  "message": "xx xx xx ",
  "ctx": {
    "workflowId": "some_wf_id",
    "stepId": "some_wf_id"
  },
  "errorId": "abc123"
}

{
  "statusCode": 404,
  "timestamp": "2024-12-12T13:00:00Z",
  "path": "/api/v1/resource",
  "message": "xx xx xx ",
  "ctx": {
    "workflowId": "some_wf_id",
    "stepId": "some_wf_id"
  },
  "errorId": "abc123"
}

{
  "statusCode": 404,
  "timestamp": "2024-12-12T13:00:00Z",
  "path": "/api/v1/resource",
  "errors": {
    "fieldName1": {
      "messages": [
        "Field is required",
        "Must be a valid email address"
      ],
      "value": "invalidEmail"
    },
    "fieldName2": {
      "messages": [
        "Must be at least 18 years old"
      ],
      "value": 17
    },
    "fieldName3": {
      "messages": [
        "Must be a boolean value"
      ],
      "value": true
    },
    "fieldName4": {
      "messages": [
        "Must be a valid object"
      ],
      "value": {
        "key": "value"
      }
    },
    "fieldName5": {
      "messages": [
        "Field is missing"
      ],
      "value": null
    },
    "fieldName6": {
      "messages": [
        "Undefined value"
      ]
    }
  },
  "message": "xx xx xx ",
  "ctx": {
    "workflowId": "some_wf_id",
    "stepId": "some_wf_id"
  },
  "errorId": "abc123"
}

"API rate limit exceeded"

{
  "statusCode": 404,
  "timestamp": "2024-12-12T13:00:00Z",
  "path": "/api/v1/resource",
  "message": "xx xx xx ",
  "ctx": {
    "workflowId": "some_wf_id",
    "stepId": "some_wf_id"
  },
  "errorId": "abc123"
}

"Please wait some time, then try again."

Create a channel endpoint to register a subscriber-specific delivery target (Slack channel, phone number, PagerDuty routing key, Tool Webhook URL, and other variants). The request body uses a discriminated type field; each variant carries its own endpoint object shape.

`tool_webhook` variant

Use type tool_webhook with a Tool Webhook integration configured for Dynamic routing. A subscriber may have multiple tool_webhook endpoints on the same integration — Novu delivers the Tool step once per endpoint.

Field	Type	Description
`type`	`"tool_webhook"`	Discriminator for Tool Webhook dynamic routing.
`integrationIdentifier`	`string`	Identifier of the Tool Webhook integration.
`subscriberId`	`string`	Subscriber that owns this destination URL.
`createSubscriberIfMissing`	`boolean`	Optional. When `true`, creates the subscriber if missing. Defaults to `false`.
`endpoint.url`	`string`	Required. `http:` or `https:` URL. Stored encrypted on the linked channel connection.
`endpoint.headers`	`Record<string, string>`	Optional. Per-endpoint headers; override integration defaults on key collision. Values stored encrypted.
`endpoint.method`	`"POST" \| "PUT" \| "PATCH"`	Optional. Overrides the integration HTTP method for this endpoint.

Example:

curl -L -X POST 'https://api.novu.co/v1/channel-endpoints' \
-H 'Content-Type: application/json' \
-H 'Authorization: ApiKey <NOVU_SECRET_KEY>' \
-d '{
  "type": "tool_webhook",
  "integrationIdentifier": "tool-webhook",
  "subscriberId": "user-123",
  "createSubscriberIfMissing": true,
  "endpoint": {
    "url": "https://customer.example.com/hooks/novu",
    "headers": { "Authorization": "Bearer token" },
    "method": "POST"
  }
}'

See the Tool Webhook setup guide for static vs dynamic routing, header/body merge, and HMAC verification.

Authorizations

Authorization

string

header

required

API key authentication. Allowed headers-- "Authorization: ApiKey <novu_secret_key>".

Headers

idempotency-key

string

A header for idempotency purposes

Body

application/json

Channel endpoint creation request. The structure varies based on the type field.

subscriberId

string

required

The subscriber ID to which the channel endpoint is linked

Example:

"subscriber-123"

integrationIdentifier

string

required

The identifier of the integration to use for this channel endpoint.

Example:

"slack-prod"

type

enum<string>

required

Type of channel endpoint

Available options:

slack_channel

Example:

"slack_channel"

endpoint

object

required

Slack channel endpoint data

Show child attributes

identifier

string

The unique identifier for the channel endpoint. If not provided, one will be generated automatically.

Example:

"slack-channel-user123-abc4"

createSubscriberIfMissing

boolean

default:false

When true, the subscriber is created if it does not exist yet (existing subscribers are never modified). When false or omitted, an unknown subscriberId returns 404.

context

object

Show child attributes

connectionIdentifier

string

The identifier of the channel connection to use for this channel endpoint.

Example:

"slack-connection-abc123"

Response

Created

identifier

string

required

The unique identifier of the channel endpoint.

channel

enum<string> | null

required

The channel type (email, sms, push, chat, etc.).

Available options:

in_app,

email,

sms,

chat,

push,

tool

providerId

enum<string> | null

required

The provider identifier (e.g., sendgrid, twilio, slack, etc.).

Available options:

anypost,

emailjs,

mailgun,

mailjet,

mandrill,

nodemailer,

postmark,

sendgrid,

sendinblue,

ses,

netcore,

infobip-email,

resend,

plunk,

mailersend,

mailtrap,

clickatell,

outlook365,

novu-email,

sparkpost,

email-webhook,

braze,

novu-email-agent,

nexmo,

plivo,

sms77,

sms-central,

sns,

telnyx,

twilio,

gupshup,

firetext,

infobip-sms,

burst-sms,

bulk-sms,

isend-sms,

forty-six-elks,

kannel,

maqsam,

termii,

africas-talking,

novu-sms,

sendchamp,

generic-sms,

clicksend,

bandwidth,

messagebird,

simpletexting,

azure-sms,

ring-central,

brevo-sms,

eazy-sms,

mobishastra,

afro-message,

unifonic,

smsmode,

imedia,

sinch,

isendpro-sms,

cm-telecom,

ruach-sms,

fcm,

apns,

expo,

one-signal,

pushpad,

push-webhook,

pusher-beams,

appio,

novu,

slack,

discord,

msteams,

webex-messaging,

mattermost,

ryver,

zulip,

grafana-on-call,

getstream,

rocket-chat,

whatsapp-business,

line,

chat-webhook,

novu-slack,

telegram,

sendblue,

novu-web-chat,

anthropic,

novu-anthropic,

anthropic-aws,

pagerduty,

opsgenie,

grafana,

tool-webhook

Example:

"slack"

integrationIdentifier

string | null

required

The identifier of the integration to use for this channel endpoint.

Example:

"slack-prod"

connectionIdentifier

string | null

required

The identifier of the channel connection used for this endpoint.

Example:

"slack-connection-abc123"

subscriberId

string | null

required

The subscriber ID to which the channel endpoint is linked

Example:

"subscriber-123"

contextKeys

string[]

required

The context of the channel connection

Example:

["tenant:org-123", "region:us-east-1"]

type

enum<string>

required

Type of channel endpoint

Available options:

slack_channel,

slack_user,

webhook,

phone,

ms_teams_channel,

ms_teams_user,

telegram_chat,

webex_room,

webex_person,

line_user,

pagerduty_service,

opsgenie_integration,

grafana_oncall_integration,

tool_webhook

Example:

"slack_channel"

endpoint

object

required

Endpoint data specific to the channel type

Show child attributes

createdAt

string

required

The timestamp indicating when the channel endpoint was created, in ISO 8601 format.

updatedAt

string

required

The timestamp indicating when the channel endpoint was last updated, in ISO 8601 format.

⌘I

Csharp (SDK)

using Novu;
using Novu.Models.Components;
using Novu.Models.Requests;

var sdk = new NovuSDK(secretKey: "YOUR_SECRET_KEY_HERE");

var res = await sdk.ChannelEndpoints.CreateAsync(requestBody: ChannelEndpointsControllerCreateChannelEndpointRequestBody.CreateSlackChannel(
    new CreateSlackChannelEndpointDto() {
        SubscriberId = "subscriber-123",
        IntegrationIdentifier = "slack-prod",
        Type = CreateSlackChannelEndpointDtoType.SlackChannel,
        Endpoint = new SlackChannelEndpointDto() {
            ChannelId = "C123456789",
        },
    }
));

// handle response

declare(strict_types=1);

require 'vendor/autoload.php';

use novu;
use novu\Models\Components;

$sdk = novu\Novu::builder()
    ->setSecurity(
        'YOUR_SECRET_KEY_HERE'
    )
    ->build();



$response = $sdk->channelEndpoints->create(
    requestBody: new Components\CreateSlackChannelEndpointDto(
        subscriberId: 'subscriber-123',
        integrationIdentifier: 'slack-prod',
        type: Components\CreateSlackChannelEndpointDtoType::SlackChannel,
        endpoint: new Components\SlackChannelEndpointDto(
            channelId: 'C123456789',
        ),
    )
);

if ($response->getChannelEndpointResponseDto !== null) {
    // handle response
}

import novu_py
from novu_py import Novu


with Novu(
    secret_key="YOUR_SECRET_KEY_HERE",
) as novu:

    res = novu.channel_endpoints.create(request_body={
        "subscriber_id": "subscriber-123",
        "create_subscriber_if_missing": False,
        "integration_identifier": "slack-prod",
        "type": novu_py.CreateSlackChannelEndpointDtoType.SLACK_CHANNEL,
        "endpoint": {
            "channel_id": "C123456789",
        },
    })

    # Handle response
    print(res)

package main

import(
	"context"
	"github.com/novuhq/novu-go/v3"
	"github.com/novuhq/novu-go/v3/models/components"
	"github.com/novuhq/novu-go/v3/models/operations"
	"log"
)

func main() {
    ctx := context.Background()

    s := v3.New(
        v3.WithSecurity("YOUR_SECRET_KEY_HERE"),
    )

    res, err := s.ChannelEndpoints.Create(ctx, operations.CreateChannelEndpointsControllerCreateChannelEndpointRequestBodySlackChannel(
        components.CreateSlackChannelEndpointDto{
            SubscriberID: "subscriber-123",
            IntegrationIdentifier: "slack-prod",
            Type: components.CreateSlackChannelEndpointDtoTypeSlackChannel,
            Endpoint: components.SlackChannelEndpointDto{
                ChannelID: "C123456789",
            },
        },
    ), nil)
    if err != nil {
        log.Fatal(err)
    }
    if res.GetChannelEndpointResponseDto != nil {
        switch res.GetChannelEndpointResponseDto.Endpoint.Type {
            case components.EndpointTypeSlackChannelEndpointDto:
                // res.GetChannelEndpointResponseDto.Endpoint.SlackChannelEndpointDto is populated
            case components.EndpointTypeSlackUserEndpointDto:
                // res.GetChannelEndpointResponseDto.Endpoint.SlackUserEndpointDto is populated
            case components.EndpointTypeWebhookEndpointDto:
                // res.GetChannelEndpointResponseDto.Endpoint.WebhookEndpointDto is populated
            case components.EndpointTypePhoneEndpointDto:
                // res.GetChannelEndpointResponseDto.Endpoint.PhoneEndpointDto is populated
            case components.EndpointTypeMsTeamsChannelEndpointDto:
                // res.GetChannelEndpointResponseDto.Endpoint.MsTeamsChannelEndpointDto is populated
            case components.EndpointTypeMsTeamsUserEndpointDto:
                // res.GetChannelEndpointResponseDto.Endpoint.MsTeamsUserEndpointDto is populated
            case components.EndpointTypeTelegramChatEndpointDto:
                // res.GetChannelEndpointResponseDto.Endpoint.TelegramChatEndpointDto is populated
            case components.EndpointTypeWebexRoomEndpointDto:
                // res.GetChannelEndpointResponseDto.Endpoint.WebexRoomEndpointDto is populated
            case components.EndpointTypeWebexPersonEndpointDto:
                // res.GetChannelEndpointResponseDto.Endpoint.WebexPersonEndpointDto is populated
            case components.EndpointTypeLineUserEndpointDto:
                // res.GetChannelEndpointResponseDto.Endpoint.LineUserEndpointDto is populated
            case components.EndpointTypePagerDutyServiceEndpointDto:
                // res.GetChannelEndpointResponseDto.Endpoint.PagerDutyServiceEndpointDto is populated
            case components.EndpointTypeOpsgenieIntegrationEndpointDto:
                // res.GetChannelEndpointResponseDto.Endpoint.OpsgenieIntegrationEndpointDto is populated
            case components.EndpointTypeGrafanaOnCallIntegrationEndpointDto:
                // res.GetChannelEndpointResponseDto.Endpoint.GrafanaOnCallIntegrationEndpointDto is populated
            case components.EndpointTypeToolWebhookEndpointDto:
                // res.GetChannelEndpointResponseDto.Endpoint.ToolWebhookEndpointDto is populated
        }

    }
}

import { Novu } from "@novu/api";

const novu = new Novu({
  secretKey: "YOUR_SECRET_KEY_HERE",
});

async function run() {
  const result = await novu.channelEndpoints.create({
    subscriberId: "subscriber-123",
    createSubscriberIfMissing: false,
    integrationIdentifier: "slack-prod",
    type: "slack_channel",
    endpoint: {
      channelId: "C123456789",
    },
  });

  console.log(result);
}

run();

curl --request POST \
  --url https://api.novu.co/v1/channel-endpoints \
  --header 'Authorization: <api-key>' \
  --header 'Content-Type: application/json' \
  --data '
{
  "subscriberId": "subscriber-123",
  "integrationIdentifier": "slack-prod",
  "type": "slack_channel",
  "endpoint": {
    "channelId": "C123456789"
  },
  "identifier": "slack-channel-user123-abc4",
  "createSubscriberIfMissing": false,
  "context": {},
  "connectionIdentifier": "slack-connection-abc123"
}
'

const options = {
  method: 'POST',
  headers: {Authorization: '<api-key>', 'Content-Type': 'application/json'},
  body: JSON.stringify({
    subscriberId: 'subscriber-123',
    integrationIdentifier: 'slack-prod',
    type: 'slack_channel',
    endpoint: {channelId: 'C123456789'},
    identifier: 'slack-channel-user123-abc4',
    createSubscriberIfMissing: false,
    context: {},
    connectionIdentifier: 'slack-connection-abc123'
  })
};

fetch('https://api.novu.co/v1/channel-endpoints', options)
  .then(res => res.json())
  .then(res => console.log(res))
  .catch(err => console.error(err));

HttpResponse<String> response = Unirest.post("https://api.novu.co/v1/channel-endpoints")
  .header("Authorization", "<api-key>")
  .header("Content-Type", "application/json")
  .body("{\n  \"subscriberId\": \"subscriber-123\",\n  \"integrationIdentifier\": \"slack-prod\",\n  \"type\": \"slack_channel\",\n  \"endpoint\": {\n    \"channelId\": \"C123456789\"\n  },\n  \"identifier\": \"slack-channel-user123-abc4\",\n  \"createSubscriberIfMissing\": false,\n  \"context\": {},\n  \"connectionIdentifier\": \"slack-connection-abc123\"\n}")
  .asString();

require 'uri'
require 'net/http'

url = URI("https://api.novu.co/v1/channel-endpoints")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["Authorization"] = '<api-key>'
request["Content-Type"] = 'application/json'
request.body = "{\n  \"subscriberId\": \"subscriber-123\",\n  \"integrationIdentifier\": \"slack-prod\",\n  \"type\": \"slack_channel\",\n  \"endpoint\": {\n    \"channelId\": \"C123456789\"\n  },\n  \"identifier\": \"slack-channel-user123-abc4\",\n  \"createSubscriberIfMissing\": false,\n  \"context\": {},\n  \"connectionIdentifier\": \"slack-connection-abc123\"\n}"

response = http.request(request)
puts response.read_body

{
  "identifier": "<string>",
  "channel": "in_app",
  "providerId": "slack",
  "integrationIdentifier": "slack-prod",
  "connectionIdentifier": "slack-connection-abc123",
  "subscriberId": "subscriber-123",
  "contextKeys": [
    "tenant:org-123",
    "region:us-east-1"
  ],
  "type": "slack_channel",
  "endpoint": {
    "channelId": "C123456789"
  },
  "createdAt": "<string>",
  "updatedAt": "<string>"
}

{
  "statusCode": 404,
  "timestamp": "2024-12-12T13:00:00Z",
  "path": "/api/v1/resource",
  "message": "xx xx xx ",
  "ctx": {
    "workflowId": "some_wf_id",
    "stepId": "some_wf_id"
  },
  "errorId": "abc123"
}

{
  "statusCode": 404,
  "timestamp": "2024-12-12T13:00:00Z",
  "path": "/api/v1/resource",
  "message": "xx xx xx ",
  "ctx": {
    "workflowId": "some_wf_id",
    "stepId": "some_wf_id"
  },
  "errorId": "abc123"
}

{
  "statusCode": 404,
  "timestamp": "2024-12-12T13:00:00Z",
  "path": "/api/v1/resource",
  "message": "xx xx xx ",
  "ctx": {
    "workflowId": "some_wf_id",
    "stepId": "some_wf_id"
  },
  "errorId": "abc123"
}

{
  "statusCode": 404,
  "timestamp": "2024-12-12T13:00:00Z",
  "path": "/api/v1/resource",
  "message": "xx xx xx ",
  "ctx": {
    "workflowId": "some_wf_id",
    "stepId": "some_wf_id"
  },
  "errorId": "abc123"
}

{
  "statusCode": 404,
  "timestamp": "2024-12-12T13:00:00Z",
  "path": "/api/v1/resource",
  "message": "xx xx xx ",
  "ctx": {
    "workflowId": "some_wf_id",
    "stepId": "some_wf_id"
  },
  "errorId": "abc123"
}

{
  "statusCode": 404,
  "timestamp": "2024-12-12T13:00:00Z",
  "path": "/api/v1/resource",
  "message": "xx xx xx ",
  "ctx": {
    "workflowId": "some_wf_id",
    "stepId": "some_wf_id"
  },
  "errorId": "abc123"
}

{
  "statusCode": 404,
  "timestamp": "2024-12-12T13:00:00Z",
  "path": "/api/v1/resource",
  "message": "xx xx xx ",
  "ctx": {
    "workflowId": "some_wf_id",
    "stepId": "some_wf_id"
  },
  "errorId": "abc123"
}

{
  "statusCode": 404,
  "timestamp": "2024-12-12T13:00:00Z",
  "path": "/api/v1/resource",
  "message": "xx xx xx ",
  "ctx": {
    "workflowId": "some_wf_id",
    "stepId": "some_wf_id"
  },
  "errorId": "abc123"
}

{
  "statusCode": 404,
  "timestamp": "2024-12-12T13:00:00Z",
  "path": "/api/v1/resource",
  "message": "xx xx xx ",
  "ctx": {
    "workflowId": "some_wf_id",
    "stepId": "some_wf_id"
  },
  "errorId": "abc123"
}

{
  "statusCode": 404,
  "timestamp": "2024-12-12T13:00:00Z",
  "path": "/api/v1/resource",
  "errors": {
    "fieldName1": {
      "messages": [
        "Field is required",
        "Must be a valid email address"
      ],
      "value": "invalidEmail"
    },
    "fieldName2": {
      "messages": [
        "Must be at least 18 years old"
      ],
      "value": 17
    },
    "fieldName3": {
      "messages": [
        "Must be a boolean value"
      ],
      "value": true
    },
    "fieldName4": {
      "messages": [
        "Must be a valid object"
      ],
      "value": {
        "key": "value"
      }
    },
    "fieldName5": {
      "messages": [
        "Field is missing"
      ],
      "value": null
    },
    "fieldName6": {
      "messages": [
        "Undefined value"
      ]
    }
  },
  "message": "xx xx xx ",
  "ctx": {
    "workflowId": "some_wf_id",
    "stepId": "some_wf_id"
  },
  "errorId": "abc123"
}

"API rate limit exceeded"

{
  "statusCode": 404,
  "timestamp": "2024-12-12T13:00:00Z",
  "path": "/api/v1/resource",
  "message": "xx xx xx ",
  "ctx": {
    "workflowId": "some_wf_id",
    "stepId": "some_wf_id"
  },
  "errorId": "abc123"
}

"Please wait some time, then try again."

Getting Started

Notification delivery

Agents

Data

Workflows & content

Platform & channels

Create a channel endpoint

`tool_webhook` variant

Authorizations

Headers

Body

Response

​tool_webhook variant

Authorizations

Headers

Body

Response

`tool_webhook` variant