> ## Documentation Index
> Fetch the complete documentation index at: https://www.cometchat.com/docs/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 Android SDK.

## Mark Messages as Delivered

You can mark the messages for a particular conversation as read using the `markAsDelivered()` method. This method takes the following parameters as input:

| Parameter      | Information                                                                                                                                                                         |
| -------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `messageId`    | The ID of the message above which all the messages for a particular conversation are to be marked as read.                                                                          |
| `receiverId`   | In case of one to one conversation message's sender `UID` will be the receipt's receiver Id. In case of group conversation message's receiver Id will be the receipt's receiver Id. |
| `receiverType` | Type of the receiver. Could be either of the two values (user/group).                                                                                                               |
| `senderId`     | The `UID` of the sender of the message.                                                                                                                                             |

Messages for both user & group conversations can be marked as read using this method.

Ideally, you would like to mark all the messages as delivered for any conversation when the user opens the chat window for that conversation. This includes two scenarios:

1. **When the list of messages for the conversation is fetched**: In this case you need to obtain the last message in the list of messages and pass the message ID of that message to the markAsDelivered() method.
2. **When the user is on the chat window and a real-time message is received:** In this case you need to obtain the message ID of the message and pass it to the markAsDelivered() method.

<Tabs>
  <Tab title="Java (User)">
    ```java theme={null}
    CometChat.markAsDelivered(message.getId(), message.getReceiverUid(), CometChatConstants.RECEIVER_TYPE_USER, message.getSender().getUid());
    ```
  </Tab>

  <Tab title="Kotlin (User)">
    ```kotlin theme={null}
    CometChat.markAsDelivered(message.id, message.receiverUid, CometChatConstants.RECEIVER_TYPE_USER, message.sender.uid)
    ```
  </Tab>

  <Tab title="Java (Group)">
    ```java theme={null}
    CometChat.markAsDelivered(message.getId(), message.getReceiverUid(), CometChatConstants.RECEIVER_TYPE_GROUP, message.getSender().getUid());
    ```
  </Tab>

  <Tab title="Kotlin (Group)">
    ```kotlin theme={null}
    CometChat.markAsDelivered(message.id, message.receiverUid, CometChatConstants.RECEIVER_TYPE_GROUP, message.sender.uid)
    ```
  </Tab>
</Tabs>

This method will mark all the messages before the messageId specified, for the conversation with receiverId and receiverType(user/group) as read.

In case you would like to be notified of an error if the receipts fail to go through you can use `markAsDelivered()` method with the callbacks as shown below:

<Tabs>
  <Tab title="Java (User)">
    ```java theme={null}
    CometChat.markAsDelivered(message.getId(), receiverUID, CometChatConstants.RECEIVER_TYPE_USER, message.getSender().getUid(), new CometChat.CallbackListener<Void>() {
        @Override
        public void onSuccess(Void unused) {
            Log.e(TAG, "markAsDelivered : " + "Success");
        }

        @Override
        public void onError(CometChatException e) {
            Log.e(TAG, "markAsDelivered : " + e.getMessage());
        }
    });
    ```
  </Tab>

  <Tab title="Java (Group)">
    ```java theme={null}
    CometChat.markAsDelivered(message.getId(), receiverUID, CometChatConstants.RECEIVER_TYPE_GROUP, message.getSender().getUid(), new CometChat.CallbackListener<Void>() {
        @Override
        public void onSuccess(Void unused) {
            Log.e(TAG, "markAsDelivered : " + "Success");
        }

        @Override
        public void onError(CometChatException e) {
            Log.e(TAG, "markAsDelivered : " + e.getMessage());
        }
    });  
    ```
  </Tab>

  <Tab title="Kotlin (User)">
    ```kotlin theme={null}
    CometChat.markAsDelivered(message.id, receiverUID, CometChatConstants.RECEIVER_TYPE_USER, message.sender.uid, object : CallbackListener<Void?>() {
        override fun onSuccess(unused: Void?) {
            Log.e(TAG, "markAsDelivered : " + "Success")
        }

        override fun onError(e: CometChatException) {
            Log.e(TAG, "markAsDelivered : " + e.message)
        }
    })
    ```
  </Tab>

  <Tab title="Kotlin (Group)">
    ```kotlin theme={null}
    CometChat.markAsDelivered(message.id, receiverUID, CometChatConstants.RECEIVER_TYPE_GROUP, message.sender.uid, object : CallbackListener<Void?>() {
        override fun onSuccess(unused: Void?) {
            Log.e(TAG, "markAsDelivered : " + "Success")
        }

        override fun onError(e: CometChatException) {
            Log.e(TAG, "markAsDelivered : " + e.message)
        }
    })
    ```
  </Tab>
</Tabs>

Another option the CometChat SDK provides is to pass the entire message object to the `markAsDelivered()` method.

<Tabs>
  <Tab title="Java">
    ```java theme={null}
    CometChat.markAsDelivered(baseMessage)
    ```
  </Tab>

  <Tab title="Kotlin">
    ```kotlin theme={null}
    CometChat.markAsDelivered(baseMessage)
    ```
  </Tab>
</Tabs>

In case you would like to be notified of an error if the receipts fail to go through you can use `markAsDelivered()` method with the callbacks as shown below:

<Tabs>
  <Tab title="Java">
    ```java theme={null}
    CometChat.markAsDelivered(message, new CometChat.CallbackListener<Void>() {
      @Override
        public void onSuccess(Void unused) {
        Log.e(TAG, "markAsDelivered : " + "success");
      }

      @Override
        public void onError(CometChatException e) {
        Log.e(TAG, "markAsDelivered : " + e.getMessage());
      }
    });
    ```
  </Tab>

  <Tab title="Kotlin">
    ```kotlin theme={null}
    CometChat.markAsDelivered(message, object : CallbackListener<Void?>() {
        override fun onSuccess(unused: Void?) {
            Log.e(TAG, "markAsDelivered : " + "success")
        }

        override fun onError(e: CometChatException) {
            Log.e(TAG, "markAsDelivered : " + e.message)
        }
    })
    ```
  </Tab>
</Tabs>

<Note>
  Starting v3, the messages will not be marked delivered internally by the SDK. You will have to use the `markAsDelivered()` method. You will either have to use one of the above method signatures to mark the messages as delivered.
</Note>

## Mark Messages as Read

You can mark the messages for a particular conversation as read using the `markAsRead()` method. This method takes the following parameters as input:

| Parameter      | Information                                                                                                                                                                           |
| -------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `messageId`    | The ID of the message above which all messages for a particular conversation are to be marked as read.                                                                                |
| `receiverId`   | In case of one to one conversation message's sender `UID` will be the receipt's receiver Id. In case of group conversation message's receiver Id will be the receipts's receiver Id   |
| `receiverType` | Type of the receiver. Could be either of the two values (user/group). The possible values are: 1. `CometChatConstants.RECEIVER_TYPE_USER` 2. `CometChatConstants.RECEIVER_TYPE_GROUP` |
| `senderId`     | The UID of the sender of the message                                                                                                                                                  |

Messages for both user and group conversations can be marked as read using this method.

Ideally, you should mark all the messages as read for any conversation when the user opens the chat window for that conversation. This includes two scenarios:

1. **When the list of messages for the conversation is fetched**: In this case you need to obtain the last message in the list of messages and pass the message ID of that message to the `markAsRead()` method.
2. **When the user is on the chat window and a real-time message is received:** In this case you need to obtain the message ID of the message and pass it to the `markAsRead()` method

<Tabs>
  <Tab title="Java (User Conversation)">
    ```java theme={null}
    CometChat.markAsRead(message.getId(),message.getSender().getUid(),CometChatConstants.RECEIVER_TYPE_USER,message.getSender().getUid());
    ```
  </Tab>

  <Tab title="Kotlin (User Conversation)">
    ```kotlin theme={null}
    CometChat.markAsRead(message.id, message.sender.uid, CometChatConstants.RECEIVER_TYPE_USER, message.sender.uid)
    ```
  </Tab>

  <Tab title="Java (Group Conversation)">
    ```java theme={null}
    CometChat.markAsRead(message.getId(), message.getReceiverUID(), CometChatConstants.RECEIVER_TYPE_GROUP,message.getSender().getUid())
    ```
  </Tab>

  <Tab title="Kotlin (Group Conversation)">
    ```kotlin theme={null}
    CometChat.markAsRead(message.id, message.receiverUID, CometChatConstants.RECEIVER_TYPE_GROUP, message.sender.uid)
    ```
  </Tab>
</Tabs>

This method will mark all the messages before the messageId specified, for the conversation with `receiverId` and `receiverType` (user/group) as read.

In case you would like to be notified of an error if the receipts fail to go through you can use the `markAsRead()` method with the callbacks as shown below:

<Tabs>
  <Tab title="Java (User)">
    ```java theme={null}
    CometChat.markAsRead(message.getId(), message.getSender().getUid(),CometChatConstants.RECEIVER_TYPE_USER, message.getSender().getUid(), new CometChat.CallbackListener<Void>() {
      @Override
        public void onSuccess(Void unused) {
        Log.e(TAG, "markAsRead : " + "Success");
      }
      
      @Override
        public void onError(CometChatException e) {
        Log.e(TAG, "markAsRead : " + e.getMessage());
      }
    });
    ```
  </Tab>

  <Tab title="Java (Group)">
    ```java theme={null}
    CometChat.markAsRead(message.getId(), message.getReceiverUid(), CometChatConstants.RECEIVER_TYPE_GROUP, message.getSender().getUid(), new CometChat.CallbackListener<Void>() {
      @Override
        public void onSuccess(Void unused) {
        Log.e(TAG, "markAsRead : " + "Success");
      }
      
      @Override
        public void onError(CometChatException e) {
        Log.e(TAG, "markAsRead : " + e.getMessage());
      }
    });
    ```
  </Tab>

  <Tab title="Kotlin (User)">
    ```kotlin theme={null}
    CometChat.markAsRead(message.id, message.sender.uid, CometChatConstants.RECEIVER_TYPE_USER, message.sender.uid, object : CallbackListener<Void?>() {
        override fun onSuccess(unused: Void?) {
            Log.e(TAG, "markAsRead : " + "Success")
        }
        
        override fun onError(e: CometChatException) {
            Log.e(TAG, "markAsRead : " + e.message)
        }
      }
    )
    ```
  </Tab>

  <Tab title="Kotlin (Group)">
    ```kotlin theme={null}
    CometChat.markAsRead(message.id, message.receiverUid, CometChatConstants.RECEIVER_TYPE_GROUP, message.sender.uid, object : CallbackListener<Void?>() {
        override fun onSuccess(unused: Void?) {
            Log.e(TAG, "markAsRead : " + "Success")
        }
        
        override fun onError(e: CometChatException) {
            Log.e(TAG, "markAsRead : " + e.message)
        }
      }
    )
    ```
  </Tab>
</Tabs>

Another option the CometChat SDK provides is to pass the entire message object to the markAsRead() method.

<Tabs>
  <Tab title="Java">
    ```java theme={null}
    CometChat.markAsRead(baseMessage) 
    ```
  </Tab>

  <Tab title="Kotlin">
    ```kotlin theme={null}
    CometChat.markAsRead(baseMessage)
    ```
  </Tab>
</Tabs>

In case you would like to be notified of an error if the receipts fail to go through you can use the `markAsRead()` method with the callbacks as shown below:

<Tabs>
  <Tab title="Java">
    ```java theme={null}
    CometChat.markAsRead(message, new CometChat.CallbackListener<Void>() {
      @Override
        public void onSuccess(Void unused) {
        Log.e(TAG, "markAsRead : " + "success");
      }

      @Override
        public void onError(CometChatException e) {
        Log.e(TAG, "markAsRead : " + e.getMessage());
      }
    });
    ```
  </Tab>

  <Tab title="Kotlin">
    ```kotlin theme={null}
    CometChat.markAsRead(message, object : CallbackListener<Void?>() {
      override fun onSuccess(unused: Void?) {
        Log.e(TAG, "markAsRead : " + "success")
      }
      
      override fun onError(e: CometChatException) {
        Log.e(TAG, "markAsRead : " + e.message)
      }
    })
    ```
  </Tab>
</Tabs>

<Note>
  Starting v3, the `markAsRead()` method working with v2.x is deprecated and will not work. You will either have to use one of the above method signatures to mark the messages as read.
</Note>

## Mark Messages as Unread

Use `markMessageAsUnread()` to mark a message as unread. All messages below that message in the conversation will contribute to the unread count. On success, returns an updated [`Conversation`](/sdk/reference/entities#conversation) object.

| Parameter  | Information                                                                                                                                             |
| ---------- | ------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `message`  | A non-null [`BaseMessage`](/sdk/reference/messages#basemessage) instance. All messages below this message in the conversation will be marked as unread. |
| `listener` | A non-null `CallbackListener<Conversation>` instance.                                                                                                   |

<Tabs>
  <Tab title="Java (User)">
    ```java theme={null}
    BaseMessage message = messageInstance;

    CometChat.markMessageAsUnread(message, new CometChat.CallbackListener<Conversation>() {
        @Override
        public void onSuccess(Conversation conversation) {
            Log.e("TAG", "markMessageAsUnread: onSuccess");
        }

        @Override
        public void onError(CometChatException e) {
            Log.e("TAG", "markMessageAsUnread: onError: " + e);
        }
    });
    ```
  </Tab>

  <Tab title="Kotlin (User)">
    ```kotlin theme={null}
    val message: BaseMessage = messageInstance

    CometChat.markMessageAsUnread(message, object : CometChat.CallbackListener<Conversation>() {
        override fun onSuccess(conversation: Conversation) {
            Log.e("TAG", "markMessageAsUnread: onSuccess")
        }

        override fun onError(e: CometChatException) {
            Log.e("TAG", "markMessageAsUnread: onError: $e")
        }
    })
    ```
  </Tab>

  <Tab title="Java (Group)">
    ```java theme={null}
    BaseMessage message = messageInstance;

    CometChat.markMessageAsUnread(message, new CometChat.CallbackListener<Conversation>() {
        @Override
        public void onSuccess(Conversation conversation) {
            Log.e("TAG", "markMessageAsUnread: onSuccess");
        }

        @Override
        public void onError(CometChatException e) {
            Log.e("TAG", "markMessageAsUnread: onError: " + e);
        }
    });
    ```
  </Tab>

  <Tab title="Kotlin (Group)">
    ```kotlin theme={null}
    val message: BaseMessage = messageInstance

    CometChat.markMessageAsUnread(message, object : CometChat.CallbackListener<Conversation>() {
        override fun onSuccess(conversation: Conversation) {
            Log.e("TAG", "markMessageAsUnread: onSuccess")
        }

        override fun onError(e: CometChatException) {
            Log.e("TAG", "markMessageAsUnread: onError: $e")
        }
    })
    ```
  </Tab>
</Tabs>

## Receive Delivery & Read Receipts

### Real-time 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      |

1. `onMessagesDelivered()` - This event is triggered when a message is delivered to a user.
2. `onMessagesRead()` - This event is triggered when a message is read by a user.
3. `onMessagesDeliveredToAll()` - This event is triggered when a group message is delivered to all members of the group. This event is only for Group conversations.
4. `onMessagesReadByAll()` - This event is triggered when a group message is read by all members of the group. This event is only for Group conversations.

<Tabs>
  <Tab title="Java">
    ```java theme={null}
    CometChat.addMessageListener("Listener 1", new CometChat.MessageListener() {
      @Override
      public void onMessagesDelivered(MessageReceipt messageReceipt) {
        Log.e(TAG, "onMessagesDelivered: " + messageReceipt.toString());
      }
      
      @Override
      public void onMessagesRead(MessageReceipt messageReceipt) {
        Log.e(TAG, "onMessagesRead: " + messageReceipt.toString());
      }

      @Override
      public void onMessagesDeliveredToAll(MessageReceipt messageReceipt) {
        Log.e(TAG, "onMessagesDeliveredToAll: " + messageReceipt.toString());
      }

      @Override
      public void onMessagesReadByAll(MessageReceipt messageReceipt) {
        Log.e(TAG, "onMessagesReadByAll: " + messageReceipt.toString());
      }
    });
    ```
  </Tab>

  <Tab title="Kotlin">
    ```kotlin theme={null}
    CometChat.addMessageListener("Listener 1", object : MessageListener() {
      override fun onMessagesDelivered(messageReceipt: MessageReceipt) {
        Log.e(TAG, "onMessagesDelivered: $messageReceipt")
      }

      override fun onMessagesRead(messageReceipt: MessageReceipt) {
        Log.e(TAG, "onMessagesRead: $messageReceipt")
      }
      
      override fun onMessagesDeliveredToAll(messageReceipt: MessageReceipt) {
        Log.e(TAG, "onMessagesDeliveredToAll: $messageReceipt")
      }
      
      override fun onMessagesReadByAll(messageReceipt: MessageReceipt) {
        Log.e(TAG, "onMessagesReadByAll: $messageReceipt")
      }
    })
    ```
  </Tab>
</Tabs>

You will receive events in the form of [`MessageReceipt`](/sdk/reference/auxiliary#messagereceipt) objects. The message receipt contains 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 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. This will only be present if the receiptType is delivered.                      |
| `readAt`       | The timestamp of the time when the message was read. This will only be present when the receiptType is read.                              |

### Missed Receipts

You will receive message receipts when you load offline messages. While fetching messages in bulk, the message object will have two fields i.e. `deliveredAt` and `readAt` which hold the timestamp for the time the message was delivered and read respectively. Using these two variables, the delivery and read status for a message can be obtained.

However, for a group message, if you wish to fetch the `deliveredAt` and `readAt` fields of individual member of the group you can use the below-described method.

### Receipt History for a Single Message

To fetch the message receipts, you can use the `getMessageReceipts()` method.

<Tabs>
  <Tab title="Java">
    ```java theme={null}
    private int messageId = 10101;

    CometChat.getMessageReceipts(messageId, new CometChat.CallbackListener<List<MessageReceipt>>() {
      @Override
        public void onSuccess(List<MessageReceipt> messageReceipts) {
          // Handle message receipts
      }

      @Override
        public void onError(CometChatException e) {
        // Handle error
      }
    });
    ```
  </Tab>

  <Tab title="Kotlin">
    ```kotlin theme={null}
    val messageId:Int=10101

    CometChat.getMessageReceipts(messageId, object : CallbackListener<List<MessageReceipt?>?>() {
      override fun onSuccess(messageReceipts: List<MessageReceipt?>?) {
        // Handle message receipts
      }

      override fun onError(e: CometChatException) {
        // Handle error
      }
    })
    ```
  </Tab>
</Tabs>

You will receive a list of [`MessageReceipt`](/sdk/reference/auxiliary#messagereceipt) objects in the `onSuccess()` method.

<Info>
  The following features will be available only if the **Enhanced Messaging Status** feature is enabled for your app.

  * `onMessagesDeliveredToAll` event,
  * `onMessagesReadByAll` event,
  * `deliveredAt` field in a group message,
  * `readAt` field in a group message.
  * `markMessageAsUnread` method.
</Info>

<Warning>
  Always remove message listeners when they're no longer needed (e.g., in `onDestroy()` or when navigating away). Failing to remove listeners can cause memory leaks and duplicate event handling.
</Warning>

## MessageReceipt Payload Structure

<Accordion title="MessageReceipt Object">
  The `MessageReceipt` object contains information about message delivery and read status:

  | Parameter       | Type                          | Description                                      |
  | --------------- | ----------------------------- | ------------------------------------------------ |
  | `messageId`     | long                          | ID of the message                                |
  | `sender`        | [User](#user-object-receipts) | User who sent the receipt                        |
  | `receiverType`  | String                        | Type of receiver. Values: `"user"`, `"group"`    |
  | `receiverId`    | String                        | ID of the receiver                               |
  | `timestamp`     | long                          | Unix timestamp of the receipt                    |
  | `receiptType`   | String                        | Type of receipt. Values: `"delivered"`, `"read"` |
  | `deliveredAt`   | long                          | Unix timestamp when message was delivered        |
  | `readAt`        | long                          | Unix timestamp when message was read             |
  | `messageSender` | String                        | UID of the message sender                        |

  **Sample MessageReceipt Object:**

  ```json theme={null}
  {
    "messageId": 12345,
    "sender": {
      "uid": "user_123",
      "name": "John Doe",
      "avatar": "https://example.com/avatar.png",
      "status": "online",
      "role": "default"
    },
    "receiverType": "user",
    "receiverId": "user_456",
    "timestamp": 1699900000,
    "receiptType": "read",
    "deliveredAt": 1699900001,
    "readAt": 1699900002,
    "messageSender": "user_123"
  }
  ```
</Accordion>

<Accordion title="User Object (Receipts)">
  The nested `User` object in `sender` contains:

  | Parameter       | Type           | Description                                            |
  | --------------- | -------------- | ------------------------------------------------------ |
  | `uid`           | String         | Unique identifier of the user                          |
  | `name`          | String         | Display name of the user                               |
  | `avatar`        | String         | URL to user's profile picture                          |
  | `link`          | String         | URL to user's profile page                             |
  | `role`          | String         | User role for access control                           |
  | `metadata`      | JSONObject     | Custom data set by developer                           |
  | `status`        | String         | User online status. Values: `"online"`, `"offline"`    |
  | `statusMessage` | String         | Custom status message                                  |
  | `lastActiveAt`  | long           | Unix timestamp of last activity                        |
  | `hasBlockedMe`  | boolean        | Whether this user has blocked the logged-in user       |
  | `blockedByMe`   | boolean        | Whether the logged-in user has blocked this user       |
  | `tags`          | Array\<String> | List of tags for user identification                   |
  | `deactivatedAt` | long           | Unix timestamp when user was deactivated (0 if active) |
</Accordion>

***

## Next Steps

<CardGroup cols={2}>
  <Card title="Typing Indicators" icon="keyboard" href="/sdk/android/typing-indicators">
    Show when users are typing
  </Card>

  <Card title="Receive Messages" icon="envelope" href="/sdk/android/receive-messages">
    Handle incoming messages with listeners
  </Card>

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

  <Card title="Real-Time Listeners" icon="bell" href="/sdk/android/real-time-listeners">
    Learn more about event listeners
  </Card>
</CardGroup>