Webhooks

Occurs when a user is created in TalkJS backend.

Occurs when a user is updated in TalkJS backend.

Occurs when a message is sent in a conversation.

Occurs when another user in the same conversation receives the message in the chat UI. This event will get sent at most once for every member of a conversation other than the sender.

Occurs when the content or metadata of the message is updated. Note that message.updated is not called when the message has been read (message.read).

Occurs when the message has been deleted.

Occurs when a conversation is deleted via the REST API

Occurs when TalkJS decided that a notification is to be sent to a user. In particular, this is the case when both of the following conditions are met:

1. One or more messages have been sent by one or more users and the user(s) stopped typing or went offline, indicating that no further messages are to be expected
2. Another user was not currently online and looking at the same conversation, indicating that they might have missed the messages sent and thus should be notified.

This webhook event is triggered even if notify is set to false for individual participants. This makes it possible to create additional custom logic for if each participant should be notified. Using the webhook payload data you can check the participants notify setting within the webhook payload itself and determine if the notification should be sent or dropped, for example:

1const conversation = event.data.conversation;
2  const recipient = event.data.recipient;
3  if(conversation.participants[recipient.id].notify) { ... }

Occurs when TalkJS has actually sent the aforementioned notification. May be triggered more than once for each notification if TalkJS notifies a user both via email and SMS. Does not get triggered for mobile push notifications.

Occurs when a email was successfully delivered.

Occurs when an email was not successfully delivered. It is triggered for bounces and spam complaints that resulted from outgoing email.

Occurs when a user opens an email notification in an email client. Note that it may not always be triggered, because user’s email client might be blocking tracking pixels.

Occurs when a user clicks a link inside an email notification.

The structure for the user.created event is as follows:

1type UserCreatedEvent = {
2  id: string;
3  createdAt: UnixMilliseconds;
4  data: {
5    user: User;
6  };
7};

The structure for the user.updated event is as follows:

1type UserUpdatedEvent = {
2  id: string;
3  createdAt: UnixMilliseconds;
4  data: {
5    user: User;
6  };
7  type: 'user.updated';
8};

The structure for the conversation.deleted event is as follows:

1type ConversationDeletedEvent = {
2  id: string;
3  createdAt: UnixMilliseconds;
4  data: {
5    conversation: Conversation;
6  };
7  type: 'conversation.deleted';
8};

The structure for the message.sent event is as follows:

1type MessageSentEvent = {
2  id: string;
3  createdAt: UnixMilliseconds;
4  data: {
5    sender: User;
6    conversation: Conversation;
7    message: Message;
8  };
9  type: 'message.sent';
10};

The structure for the message.read event is as follows:

1type MessageReadEvent = {
2  id: string;
3  createdAt: UnixMilliseconds;
4  data: {
5    recipient: User;
6    conversation: Conversation;
7    message: Message;
8  };
9  type: 'message.read';
10};

The structure for the message.updated event is as follows:

1type MessageUpdatedEvent = {
2  id: string;
3  createdAt: UnixMilliseconds;
4  data: {
5    sender: User;
6    conversation: Conversation;
7    message: Message;
8  };
9  type: 'message.updated';
10};

The structure for the message.deleted event is as follows:

1type MessageDeleted = {
2  id: string;
3  createdAt: UnixMilliseconds;
4  data: {
5    sender: User | null;
6    conversation: Conversation;
7    message: Message;
8  };
9  type: 'message.deleted';
10};

The structure for the notification.triggered event is as follows:

1type NotificationTriggered = {
2  id: string;
3  createdAt: UnixMilliseconds;
4  data: {
5    notificationId: string;
6    recipient: User;
7    sender: User;
8    conversation: Conversation;
9    messages: Message[];
10  };
11  type: 'notification.triggered';
12};

The structure for the notification.sent event is as follows:

1type NotificationSent = {
2  id: string;
3  createdAt: UnixMilliseconds;
4  data: {
5    notificationId: string;
6    recipient: User;
7    sender: User;
8    conversation: Conversation;
9    messages: Message[];
10    channel: 'email' | 'sms';
11  };
12  type: 'notification.sent';
13};

The structure for the notification.delivered event is as follows:

1type NotificationDelivered = {
2  id: string;
3  createdAt: UnixMilliseconds;
4  data: {
5    notificationId: NotificationId;
6    conversation: Conversation;
7    messages: Message[];
8    recipient: User;
9    sender: User;
10    channel: 'email';
11  };
12  type: 'notification.delivered';
13};

The structure for the notification.bounced event is as follows:

1type NotificationBounced = {
2  id: string;
3  createdAt: UnixMilliseconds;
4  data: {
5    notificationId: NotificationId;
6    conversation: Conversation;
7    messages: Message[];
8    recipient: User;
9    sender: User;
10    channel: 'email';
11  };
12  type: 'notification.bounced';
13};

The structure for the notification.opened event is as follows:

1type NotificationOpened = {
2  id: string;
3  createdAt: UnixMilliseconds;
4  data: {
5    notificationId: NotificationId;
6    conversation: Conversation;
7    messages: Message[];
8    recipient: User;
9    sender: User;
10    channel: 'email';
11  };
12  type: 'notification.opened';
13};

The structure for the notification.link.clicked event is as follows:

1type NotificationLinkClicked = {
2  id: string;
3  createdAt: UnixMilliseconds;
4  data: {
5    notificationId: NotificationId;
6    conversation: Conversation;
7    messages: Message[];
8    recipient: User;
9    sender: User;
10    channel: 'email';
11    originalUrl: string;
12  };
13  type: 'notification.link.clicked';
14};