> ## Documentation Index
> Fetch the complete documentation index at: https://cometchat-22654f5b-docs-llms-scoped-indexes.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

# Delivery & Read Receipts

> Mark messages as delivered, read, or unread and receive real-time receipt events using the CometChat React Native SDK.

<Accordion title="AI Integration Quick Reference">
  | Field | Value |
  | - | - |
  | Package | `@cometchat/chat-sdk-react-native` |
  | Import | `import { CometChat } from "@cometchat/chat-sdk-react-native";` |
  | Key Classes | `MessageReceipt`, `MessageListener`, `Conversation`, `CometChatException` |
  | Key Methods | `markAsDelivered()`, `markAsRead()`, `markConversationAsDelivered()`, `markConversationAsRead()`, `markMessageAsUnread()`, `getMessageReceipts()`, `addMessageListener()`, `removeMessageListener()` |
  | Listener Events | `onMessagesDelivered`, `onMessagesRead`, `onMessagesDeliveredToAll`, `onMessagesReadByAll` |
  | Primary output | `markAsDelivered()` / `markAsRead()` are fire-and-forget — they resolve but return no receipt; `getMessageReceipts()` resolves to `MessageReceipt[]` |
  | Prerequisites | SDK initialized via `CometChat.init()`, user logged in via `CometChat.login()` |
  | Related | [Receive Messages](/sdk/react-native/receive-messages), [Typing Indicators](/sdk/react-native/typing-indicators), [Retrieve Conversations](/sdk/react-native/retrieve-conversations) |
  | Constraints | `markAsDelivered()` / `markAsRead()` are typed `any` and are fire-and-forget — do not rely on a resolved value. `onMessagesDeliveredToAll` / `onMessagesReadByAll` need the **Enhanced Messaging Status** feature. Every `add*Listener()` needs a matching `remove*Listener()` with the same listener ID — unremoved listeners leak and fire after unmount. |
  | Full reference | [`MessageReceipt`](/sdk/reference/auxiliary#messagereceipt) · [`Conversation`](/sdk/reference/entities#conversation) · [`CometChatException`](/sdk/reference/auxiliary#cometchatexception) |
</Accordion>

Delivery and read receipts track whether messages have been delivered to and read by recipients.

## Mark as Delivered

Use `markAsDelivered()` to mark messages as delivered. You can pass either a message object or individual parameters.

### Using Message Object

<Tabs>
  <Tab title="TypeScript">
    ```typescript theme={null}
    CometChat.markAsDelivered(message).then(
      () => {
        console.log("Marked as delivered successfully");
      },
      (error: CometChat.CometChatException) => {
        console.log("Error marking as delivered:", error);
      }
    );
    ```
  </Tab>

  <Tab title="JavaScript">
    ```javascript theme={null}
    CometChat.markAsDelivered(message).then(
      () => {
        console.log("Marked as delivered successfully");
      },
      (error) => {
        console.log("Error marking as delivered:", error);
      }
    );
    ```
  </Tab>
</Tabs>

### Using Parameters

| Parameter | Description |
| - | - |
| `messageId` | ID of the message to mark as delivered |
| `receiverId` | For user chats: sender's UID. For groups: group GUID |
| `receiverType` | `"user"` or `"group"` |
| `senderId` | UID of the message sender |

<Tabs>
  <Tab title="TypeScript (User)">
    ```typescript theme={null}
    let messageId: string = "MESSAGE_ID";
    let receiverId: string = "MESSAGE_SENDER_UID";
    let receiverType: string = "user";
    let senderId: string = "MESSAGE_SENDER_UID";

    CometChat.markAsDelivered(messageId, receiverId, receiverType, senderId).then(
      () => {
        console.log("Marked as delivered successfully");
      },
      (error: CometChat.CometChatException) => {
        console.log("Error marking as delivered:", error);
      }
    );
    ```
  </Tab>

  <Tab title="JavaScript (User)">
    ```javascript theme={null}
    let messageId = "MESSAGE_ID";
    let receiverId = "MESSAGE_SENDER_UID";
    let receiverType = "user";
    let senderId = "MESSAGE_SENDER_UID";

    CometChat.markAsDelivered(messageId, receiverId, receiverType, senderId).then(
      () => {
        console.log("Marked as delivered successfully");
      },
      (error) => {
        console.log("Error marking as delivered:", error);
      }
    );
    ```
  </Tab>

  <Tab title="TypeScript (Group)">
    ```typescript theme={null}
    let messageId: string = "MESSAGE_ID";
    let receiverId: string = "GROUP_GUID";
    let receiverType: string = "group";
    let senderId: string = "MESSAGE_SENDER_UID";

    CometChat.markAsDelivered(messageId, receiverId, receiverType, senderId).then(
      () => {
        console.log("Marked as delivered successfully");
      },
      (error: CometChat.CometChatException) => {
        console.log("Error marking as delivered:", error);
      }
    );
    ```
  </Tab>

  <Tab title="JavaScript (Group)">
    ```javascript theme={null}
    let messageId = "MESSAGE_ID";
    let receiverId = "GROUP_GUID";
    let receiverType = "group";
    let senderId = "MESSAGE_SENDER_UID";

    CometChat.markAsDelivered(messageId, receiverId, receiverType, senderId).then(
      () => {
        console.log("Marked as delivered successfully");
      },
      (error) => {
        console.log("Error marking as delivered:", error);
      }
    );
    ```
  </Tab>
</Tabs>

## Mark Conversation as Delivered

Use `markConversationAsDelivered()` to mark all messages in a conversation as delivered.

`markConversationAsDelivered()` resolves with a `string` on success.

<Tabs>
  <Tab title="TypeScript (User)">
    ```typescript theme={null}
    let conversationWith: string = "USER_UID";
    let conversationType: string = "user";

    CometChat.markConversationAsDelivered(conversationWith, conversationType).then(
      (response: string) => {
        console.log("Conversation marked as delivered", response);
      },
      (error: CometChat.CometChatException) => {
        console.log("Error:", error);
      }
    );
    ```
  </Tab>

  <Tab title="JavaScript (User)">
    ```javascript theme={null}
    let conversationWith = "USER_UID";
    let conversationType = "user";

    CometChat.markConversationAsDelivered(conversationWith, conversationType).then(
      (response) => {
        console.log("Conversation marked as delivered", response);
      },
      (error) => {
        console.log("Error:", error);
      }
    );
    ```
  </Tab>

  <Tab title="TypeScript (Group)">
    ```typescript theme={null}
    let conversationWith: string = "GROUP_GUID";
    let conversationType: string = "group";

    CometChat.markConversationAsDelivered(conversationWith, conversationType).then(
      (response: string) => {
        console.log("Conversation marked as delivered", response);
      },
      (error: CometChat.CometChatException) => {
        console.log("Error:", error);
      }
    );
    ```
  </Tab>

  <Tab title="JavaScript (Group)">
    ```javascript theme={null}
    let conversationWith = "GROUP_GUID";
    let conversationType = "group";

    CometChat.markConversationAsDelivered(conversationWith, conversationType).then(
      (response) => {
        console.log("Conversation marked as delivered", response);
      },
      (error) => {
        console.log("Error:", error);
      }
    );
    ```
  </Tab>
</Tabs>

## Mark as Read

Use `markAsRead()` to mark messages as read. You can pass either a message object or individual parameters.

### Using Message Object

<Tabs>
  <Tab title="TypeScript">
    ```typescript theme={null}
    CometChat.markAsRead(message).then(
      () => {
        console.log("Marked as read successfully");
      },
      (error: CometChat.CometChatException) => {
        console.log("Error marking as read:", error);
      }
    );
    ```
  </Tab>

  <Tab title="JavaScript">
    ```javascript theme={null}
    CometChat.markAsRead(message).then(
      () => {
        console.log("Marked as read successfully");
      },
      (error) => {
        console.log("Error marking as read:", error);
      }
    );
    ```
  </Tab>
</Tabs>

### Using Parameters

<Tabs>
  <Tab title="TypeScript (User)">
    ```typescript theme={null}
    let messageId: string = "MESSAGE_ID";
    let receiverId: string = "MESSAGE_SENDER_UID";
    let receiverType: string = "user";
    let senderId: string = "MESSAGE_SENDER_UID";

    CometChat.markAsRead(messageId, receiverId, receiverType, senderId).then(
      () => {
        console.log("Marked as read successfully");
      },
      (error: CometChat.CometChatException) => {
        console.log("Error marking as read:", error);
      }
    );
    ```
  </Tab>

  <Tab title="JavaScript (User)">
    ```javascript theme={null}
    let messageId = "MESSAGE_ID";
    let receiverId = "MESSAGE_SENDER_UID";
    let receiverType = "user";
    let senderId = "MESSAGE_SENDER_UID";

    CometChat.markAsRead(messageId, receiverId, receiverType, senderId).then(
      () => {
        console.log("Marked as read successfully");
      },
      (error) => {
        console.log("Error marking as read:", error);
      }
    );
    ```
  </Tab>

  <Tab title="TypeScript (Group)">
    ```typescript theme={null}
    let messageId: string = "MESSAGE_ID";
    let receiverId: string = "GROUP_GUID";
    let receiverType: string = "group";
    let senderId: string = "MESSAGE_SENDER_UID";

    CometChat.markAsRead(messageId, receiverId, receiverType, senderId).then(
      () => {
        console.log("Marked as read successfully");
      },
      (error: CometChat.CometChatException) => {
        console.log("Error marking as read:", error);
      }
    );
    ```
  </Tab>

  <Tab title="JavaScript (Group)">
    ```javascript theme={null}
    let messageId = "MESSAGE_ID";
    let receiverId = "GROUP_GUID";
    let receiverType = "group";
    let senderId = "MESSAGE_SENDER_UID";

    CometChat.markAsRead(messageId, receiverId, receiverType, senderId).then(
      () => {
        console.log("Marked as read successfully");
      },
      (error) => {
        console.log("Error marking as read:", error);
      }
    );
    ```
  </Tab>
</Tabs>

## Mark Conversation as Read

Use `markConversationAsRead()` to mark all messages in a conversation as read.

<Tabs>
  <Tab title="TypeScript (User)">
    ```typescript theme={null}
    let conversationWith: string = "USER_UID";
    let conversationType: string = "user";

    CometChat.markConversationAsRead(conversationWith, conversationType).then(
      (response: string) => {
        console.log("Conversation marked as read", response);
      },
      (error: CometChat.CometChatException) => {
        console.log("Error:", error);
      }
    );
    ```
  </Tab>

  <Tab title="JavaScript (User)">
    ```javascript theme={null}
    let conversationWith = "USER_UID";
    let conversationType = "user";

    CometChat.markConversationAsRead(conversationWith, conversationType).then(
      (response) => {
        console.log("Conversation marked as read", response);
      },
      (error) => {
        console.log("Error:", error);
      }
    );
    ```
  </Tab>

  <Tab title="TypeScript (Group)">
    ```typescript theme={null}
    let conversationWith: string = "GROUP_GUID";
    let conversationType: string = "group";

    CometChat.markConversationAsRead(conversationWith, conversationType).then(
      (response: string) => {
        console.log("Conversation marked as read", response);
      },
      (error: CometChat.CometChatException) => {
        console.log("Error:", error);
      }
    );
    ```
  </Tab>

  <Tab title="JavaScript (Group)">
    ```javascript theme={null}
    let conversationWith = "GROUP_GUID";
    let conversationType = "group";

    CometChat.markConversationAsRead(conversationWith, conversationType).then(
      (response) => {
        console.log("Conversation marked as read", response);
      },
      (error) => {
        console.log("Error:", error);
      }
    );
    ```
  </Tab>
</Tabs>

## Real-Time Receipt Events

Register a `MessageListener` to receive delivery and read receipt events.

| Callback | Description |
| - | - |
| `onMessagesDelivered` | Message delivered to a user |
| `onMessagesRead` | Message read by a user |
| `onMessagesDeliveredToAll` | Group message delivered to all members |
| `onMessagesReadByAll` | Group message read by all members |

<Tabs>
  <Tab title="TypeScript">
    ```typescript theme={null}
    let listenerID: string = "UNIQUE_LISTENER_ID";

    CometChat.addMessageListener(
      listenerID,
      new CometChat.MessageListener({
        onMessagesDelivered: (messageReceipt: CometChat.MessageReceipt) => {
          console.log("Message delivered:", messageReceipt);
        },
        onMessagesRead: (messageReceipt: CometChat.MessageReceipt) => {
          console.log("Message read:", messageReceipt);
        },
        onMessagesDeliveredToAll: (messageReceipt: CometChat.MessageReceipt) => {
          console.log("Message delivered to all group members:", messageReceipt);
        },
        onMessagesReadByAll: (messageReceipt: CometChat.MessageReceipt) => {
          console.log("Message read by all group members:", messageReceipt);
        }
      })
    );
    ```
  </Tab>

  <Tab title="JavaScript">
    ```javascript theme={null}
    let listenerID = "UNIQUE_LISTENER_ID";

    CometChat.addMessageListener(
      listenerID,
      new CometChat.MessageListener({
        onMessagesDelivered: (messageReceipt) => {
          console.log("Message delivered:", messageReceipt);
        },
        onMessagesRead: (messageReceipt) => {
          console.log("Message read:", messageReceipt);
        },
        onMessagesDeliveredToAll: (messageReceipt) => {
          console.log("Message delivered to all group members:", messageReceipt);
        },
        onMessagesReadByAll: (messageReceipt) => {
          console.log("Message read by all group members:", messageReceipt);
        }
      })
    );
    ```
  </Tab>
</Tabs>

You will receive events in the form of [`MessageReceipt`](/sdk/reference/auxiliary#messagereceipt) objects containing the following parameters:

| Parameter | Information |
| - | - |
| `messageId` | The ID of the message prior to which all the messages for that particular conversation have been marked as read. |
| `sender` | [User](/sdk/reference/entities#user) object containing the details of the user who has marked the message as read. System User for `deliveredToAll` & `readByAll` events. |
| `receiverId` | ID of the receiver whose conversation has been marked as read. |
| `receiverType` | Type of the receiver (user/group) |
| `receiptType` | Type of the receipt (read/delivered) |
| `deliveredAt` | The timestamp of the time when the message was delivered. Only present if the receiptType is delivered. |
| `readAt` | The timestamp of the time when the message was read. Only present when the receiptType is read. |

The `markAsDelivered()` and `markAsRead()` methods are fire-and-forget — they do not return a [`MessageReceipt`](/sdk/reference/auxiliary#messagereceipt) object. Use the listener callbacks above to receive delivery and read confirmations.

<Info>
  The following features require **Enhanced Messaging Status** to be enabled for your app:

  * `onMessagesDeliveredToAll` event
  * `onMessagesReadByAll` event
  * `deliveredAt` field in group messages
  * `readAt` field in group messages
  * `markMessageAsUnread()` method
</Info>

<Warning>
  Always remove listeners when no longer needed to prevent memory leaks. In React Native, place this in a cleanup function inside `useEffect` or in `componentWillUnmount`.

  ```javascript theme={null}
  CometChat.removeMessageListener("UNIQUE_LISTENER_ID");
  ```
</Warning>

### MessageReceipt Object

The listener callbacks receive a [`MessageReceipt`](/sdk/reference/auxiliary#messagereceipt) object:

| Field | Getter | Return Type | Description |
| - | - | - | - |
| messageId | `getMessageId()` | `string` | ID of the message |
| sender | `getSender()` | [`User`](/sdk/reference/entities#user) | User who triggered the receipt |
| receiverId | `getReceiverId()` | `string` | ID of the receiver |
| receiverType | `getReceiverType()` | `string` | `"user"` or `"group"` |
| receiptType | `getReceiptType()` | `string` | `"delivery"` or `"read"` |
| deliveredAt | `getDeliveredAt()` | `number` | Timestamp when delivered |
| readAt | `getReadAt()` | `number` | Timestamp when read |

## Get Receipt History

Use `getMessageReceipts()` to fetch delivery and read receipts for a specific message. Useful for group messages to see which members have received/read the message.

<Tabs>
  <Tab title="TypeScript">
    ```typescript theme={null}
    let messageId: number = 123;

    CometChat.getMessageReceipts(messageId).then(
      (receipts: CometChat.MessageReceipt[]) => {
        console.log("Message receipts:", receipts);
      },
      (error: CometChat.CometChatException) => {
        console.log("Error fetching receipts:", error);
      }
    );
    ```
  </Tab>

  <Tab title="JavaScript">
    ```javascript theme={null}
    let messageId = 123;

    CometChat.getMessageReceipts(messageId).then(
      (receipts) => {
        console.log("Message receipts:", receipts);
      },
      (error) => {
        console.log("Error fetching receipts:", error);
      }
    );
    ```
  </Tab>
</Tabs>

Returns an array of [`MessageReceipt`](/sdk/reference/auxiliary#messagereceipt) objects.

## Missed Receipts

When fetching messages, each message object includes `deliveredAt` and `readAt` timestamps indicating when the message was delivered and read.

```javascript theme={null}
let deliveredAt = message.getDeliveredAt();
let readAt = message.getReadAt();
```

## Mark as Unread

Use `markMessageAsUnread()` to mark a message as unread. This is useful for "mark as unread" functionality in conversation lists.

<Note>
  You cannot mark your own messages as unread. This method only works for messages received from other users.
</Note>

<Tabs>
  <Tab title="TypeScript">
    ```typescript theme={null}
    CometChat.markMessageAsUnread(message).then(
      (conversation: CometChat.Conversation) => {
        console.log("Message marked as unread:", conversation);
        console.log("Unread message count:", conversation.getUnreadMessageCount());
      },
      (error: CometChat.CometChatException) => {
        console.log("Error marking as unread:", error);
      }
    );
    ```
  </Tab>

  <Tab title="JavaScript">
    ```javascript theme={null}
    CometChat.markMessageAsUnread(message).then(
      (conversation) => {
        console.log("Message marked as unread:", conversation);
        console.log("Unread message count:", conversation.getUnreadMessageCount());
      },
      (error) => {
        console.log("Error marking as unread:", error);
      }
    );
    ```
  </Tab>
</Tabs>

| Parameter | Type | Description |
| - | - | - |
| `message` | [`BaseMessage`](/sdk/reference/messages#basemessage) | The message object to mark as unread |

***

## Next Steps

<CardGroup cols={2}>
  <Card title="Typing Indicators" icon="keyboard" href="/sdk/react-native/typing-indicators">
    Show real-time typing status in conversations
  </Card>

  <Card title="Receive Messages" icon="envelope-open" href="/sdk/react-native/receive-messages">
    Listen for incoming messages in real time
  </Card>

  <Card title="Retrieve Conversations" icon="comments" href="/sdk/react-native/retrieve-conversations">
    Fetch conversation list with unread counts
  </Card>

  <Card title="All Real-Time Listeners" icon="tower-broadcast" href="/sdk/react-native/real-time-listeners">
    Complete reference for all SDK event listeners
  </Card>
</CardGroup>


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