Receive A Message - CometChat Docs

AI Integration Quick Reference

Field	Value
Key Classes	`CometChat.MessageListener`, `MessagesRequestBuilder`
Key Methods	`addMessageListener()`, `fetchPrevious()`, `fetchNext()`, `getUnreadMessageCount()`
Listener Events	`onTextMessageReceived`, `onMediaMessageReceived`, `onCustomMessageReceived`
Prerequisites	SDK initialized, user logged in

Receiving messages with CometChat has two parts:

Adding a real-time listener to receive messages while your app is running
Fetching missed, unread, or historical messages when your app starts up or the user scrolls back

Real-Time Messages

Register a MessageListener to receive incoming messages as they arrive. For every activity or fragment you wish to receive messages in, register the listener using addMessageListener(). We suggest adding it in the onResume() method.

Java
Kotlin

private String listenerID = "UNIQUE_LISTENER_ID";

CometChat.addMessageListener(listenerID, new CometChat.MessageListener() {
  @Override
  public void onTextMessageReceived(TextMessage textMessage) {
      Log.d(TAG, "Text message received successfully: " + textMessage.toString());
  }

  @Override
  public void onMediaMessageReceived(MediaMessage mediaMessage) {
      Log.d(TAG, "Media message received successfully: " + mediaMessage.toString());
  }

  @Override
  public void onCustomMessageReceived(CustomMessage customMessage) {
      Log.d(TAG, "Custom message received successfully: " + customMessage.toString());
  }
});

val listenerID:String = "UNIQUE_LISTENER_ID"

CometChat.addMessageListener(listenerID, object : MessageListener() {
  override fun onTextMessageReceived(textMessage: TextMessage) {
      Log.d(TAG, "Text message received successfully: $textMessage")
  }

  override fun onMediaMessageReceived(mediaMessage: MediaMessage) {
      Log.d(TAG, "Media message received successfully: $mediaMessage")
  }

  override fun onCustomMessageReceived(customMessage: CustomMessage) {
      Log.d(TAG, "Custom message received successfully: $customMessage")
  }
})

Parameter	Description
`listenerID`	An ID that uniquely identifies that listener. We recommend using the activity or fragment name

Remove the listener when you no longer need it. Typically, this can be added in the onPause() method.

Java
Kotlin

private String listenerID = "UNIQUE_LISTENER_ID";

CometChat.removeMessageListener(listenerID);

val listenerID:String = "UNIQUE_LISTENER_ID"

CometChat.removeMessageListener(listenerID)

Always remove listeners when they’re no longer needed (e.g., in onPause()). Failing to do so can cause memory leaks and duplicate event handling.

As a sender, you will not receive your own message in a real-time message event. However, if a user is logged-in using multiple devices, they will receive an event for their own message in other devices.

Missed Messages

Fetch messages that arrived while your app was offline. Use getLastDeliveredMessageId() to find where you left off, then call fetchNext() to get everything after that point. Call fetchNext() repeatedly on the same request object to paginate.

One-on-One
Group

Java
Kotlin

private int limit = 30;
private int latestId = CometChat.getLastDeliveredMessageId();
private String UID = "cometchat-uid-1";

MessagesRequest messagesRequest = new MessagesRequest.MessagesRequestBuilder()
      .setMessageId(latestId)
      .setLimit(limit)
      .setUID(UID)
      .build();

messagesRequest.fetchNext(new CometChat.CallbackListener<List<BaseMessage>>() {
  @Override
  public void onSuccess(List<BaseMessage> list) {
      for (BaseMessage message : list) {
          if (message instanceof TextMessage) {
              Log.d(TAG, "Text message received successfully: " +
                      ((TextMessage) message).toString());
          } else if (message instanceof MediaMessage) {
              Log.d(TAG, "Media message received successfully: " +
                      ((MediaMessage) message).toString());
          }
      }
  }

  @Override
  public void onError(CometChatException e) {
      Log.d(TAG, "Message fetching failed with exception: " + e.getMessage());
  }
});

lateinit var messagesRequest: MessagesRequest
val latestId = CometChat.getLastDeliveredMessageId()
val limit: Int = 30
val UID: String = "cometchat-uid-1"

val messagesRequest = MessagesRequestBuilder()
  .setMessageId(latestId)
  .setLimit(limit)
  .setUID(UID)
  .build()

messagesRequest.fetchNext(object : CallbackListener<List<BaseMessage?>>() {
  override fun onSuccess(list: List<BaseMessage?>) {
      for (message in list) {
          if (message is TextMessage) {
              Log.d(
                  TAG, "Text message received successfully: " +
                          message.toString()
              )
          } else if (message is MediaMessage) {
              Log.d(
                  TAG, "Media message received successfully: " +
                          message.toString()
              )
          }
      }
  }

  override fun onError(e: CometChatException) {
      Log.d(TAG, "Message fetching failed with exception: " + e.message)
  }
})

Java
Kotlin

private int limit = 30;
private int latestId = CometChat.getLastDeliveredMessageId();
private String GUID = "cometchat-guid-1";

MessagesRequest messagesRequest = new MessagesRequest.MessagesRequestBuilder()
      .setMessageId(latestId)
      .setLimit(limit)
      .setGUID(GUID)
      .build();

messagesRequest.fetchNext(new CometChat.CallbackListener<List<BaseMessage>>() {
  @Override
  public void onSuccess(List<BaseMessage> list) {
      for (BaseMessage message : list) {
          if (message instanceof TextMessage) {
              Log.d(TAG, "Text message received successfully: " + ((TextMessage) message).toString());
          } else if (message instanceof MediaMessage) {
              Log.d(TAG, "Media message received successfully: " + ((MediaMessage)message).toString());
          }
      }
  }

  @Override
  public void onError(CometChatException e) {
      Log.d(TAG, "Message fetching failed with exception: " + e.getMessage());
  }
});

lateinit var messagesRequest: MessagesRequest
val latestId = CometChat.getLastDeliveredMessageId()
val limit: Int = 30
val GUID: String = "cometchat-uid-1"

messagesRequest = MessagesRequestBuilder()
  .setMessageId(latestId)
  .setLimit(limit)
  .setGUID(GUID)
  .build()

messagesRequest.fetchNext(object : CallbackListener<List<BaseMessage?>>() {
  override fun onSuccess(list: List<BaseMessage?>) {
      for (message in list) {
          if (message is TextMessage) {
              Log.d(
                  TAG, "Text message received successfully: " +
                          message.toString()
              )
          } else if (message is MediaMessage) {
              Log.d(
                  TAG, "Media message received successfully: " +
                          message.toString()
              )
          }
      }
  }

  override fun onError(e: CometChatException) {
      Log.d(TAG, "Message fetching failed with exception: " + e.message)
  }
})

Unread Messages

Fetch unread messages by adding setUnread(true) to the builder. Use fetchPrevious() to retrieve them.

One-on-One
Group

Java
Kotlin

String UID = "cometchat-uid-1";

MessagesRequest messagesRequest = new MessagesRequest.MessagesRequestBuilder()
      .setUnread(true)
      .setLimit(20)
      .setUID(UID)
      .build();

messagesRequest.fetchPrevious(new CometChat.CallbackListener<List<BaseMessage>>() {
  @Override
  public void onSuccess(List<BaseMessage> list) {
      for (BaseMessage message : list) {
          if (message instanceof TextMessage) {
              Log.d(TAG, "Text message received successfully: " +((TextMessage) message).toString());
          } else if (message instanceof MediaMessage) {
              Log.d(TAG, "Media message received successfully: " +((MediaMessage) message).toString());
          }
      }
  }

  @Override
  public void onError(CometChatException e) {
      Log.d(TAG, "Message fetching failed with exception: " + e.getMessage());
  }
});

val UID:String = "cometchat-uid-1"

val messagesRequest = MessagesRequestBuilder()
  .setUnread(true)
  .setLimit(20)
  .setUID(UID)
  .build()

messagesRequest.fetchPrevious(object : CallbackListener<List<BaseMessage?>>() {
  override fun onSuccess(list: List<BaseMessage?>) {
      for (message in list) {
          if (message is TextMessage) {
              Log.d(TAG, "Text message received successfully: $message")
          } else if (message is MediaMessage) {
              Log.d(TAG, "Media message received successfully: $message")
          }
      }
  }

  override fun onError(e: CometChatException) {
      Log.d(TAG, "Message fetching failed with exception: " + e.message)
  }
})

Java
Kotlin

String GUID = "cometchat-guid-1";

MessagesRequest messagesRequest = new MessagesRequest.MessagesRequestBuilder()
      .setUnread(true)
      .setLimit(20)
      .setGUID(GUID)
      .build();

messagesRequest.fetchPrevious(new CometChat.CallbackListener<List<BaseMessage>>() {
  @Override
  public void onSuccess(List<BaseMessage> list) {
      for (BaseMessage message : list) {
          if (message instanceof TextMessage) {
              Log.d(TAG, "Text message received successfully: " + ((TextMessage) message).toString());
          } else if (message instanceof MediaMessage) {
              Log.d(TAG, "Media message received successfully: " + ((MediaMessage)message).toString());
          }
      }
  }

  @Override
  public void onError(CometChatException e) {
      Log.d(TAG, "Message fetching failed with exception: " + e.getMessage());
  }
});

val GUID:String = "cometchat-guid-1"

val messagesRequest = MessagesRequestBuilder()
  .setUnread(true)
  .setLimit(20)
  .setGUID(GUID)
  .build()

messagesRequest.fetchPrevious(object : CallbackListener<List<BaseMessage?>>() {
  override fun onSuccess(list: List<BaseMessage?>) {
      for (message in list) {
          if (message is TextMessage) {
              Log.d(TAG, "Text message received successfully: $message")
          } else if (message is MediaMessage) {
              Log.d(TAG, "Media message received successfully: $message")
          }
      }
  }

  override fun onError(e: CometChatException) {
      Log.d(TAG, "Message fetching failed with exception: " + e.message)
  }
})

The list of messages received is in the form of objects of BaseMessage class. A BaseMessage can either be an object of the TextMessage, MediaMessage, CustomMessage, Action or Call class. You can use the instanceOf operator to check the type of object.

Message History

Fetch the full conversation history using fetchPrevious(). Call it repeatedly on the same request object to paginate — useful for implementing upward scrolling.

One-on-One
Group

Java
Kotlin

private int limit = 30;
private String UID = "cometchat-uid-1"

MessagesRequest messagesRequest = new MessagesRequest.MessagesRequestBuilder()
      .setLimit(limit)
      .setUID(UID)
      .build();

messagesRequest.fetchPrevious(new CometChat.CallbackListener<List<BaseMessage>>() {
  @Override
  public void onSuccess(List<BaseMessage> list) {
      for (BaseMessage message : list) {
          if (message instanceof TextMessage) {
              Log.d(TAG, "Text message received successfully: " + ((TextMessage) message).toString());
          } else if (message instanceof MediaMessage) {
              Log.d(TAG, "Media message received successfully: " + ((MediaMessage)message).toString());
          }
      }
  }

  @Override
  public void onError(CometChatException e) {
      Log.d(TAG, "Message fetching failed with exception: " + e.getMessage());
  }
});

val limit: Int = 30
val UID: String = "cometchat-uid-1"

val messagesRequest = MessagesRequestBuilder()
  .setLimit(limit)
  .setUID(UID)
  .build()

messagesRequest.fetchPrevious(object : CallbackListener<List<BaseMessage?>>() {
  override fun onSuccess(list: List<BaseMessage?>) {
      for (message in list) {
          if (message is TextMessage) {
              Log.d(TAG, "Text message received successfully: $message")
          } else if (message is MediaMessage) {
              Log.d(TAG, "Media message received successfully: $message")
          }
      }
  }

  override fun onError(e: CometChatException) {
      Log.d(TAG, "Message fetching failed with exception: " + e.message)
  }
})

Java
Kotlin

private int limit = 30;
private String GUID = "cometchat-guid-1"

MessagesRequest messagesRequest = new MessagesRequest.MessagesRequestBuilder()
      .setLimit(limit)
      .setGUID(GUID)
      .build();

messagesRequest.fetchPrevious(new CometChat.CallbackListener<List<BaseMessage>>() {
  @Override
  public void onSuccess(List<BaseMessage> list) {
      for (BaseMessage message : list) {
          if (message instanceof TextMessage) {
              Log.d(TAG, "Text message received successfully: " + ((TextMessage) message).toString());
          } else if (message instanceof MediaMessage) {
              Log.d(TAG, "Media message received successfully: " + ((MediaMessage)message).toString());
          }
      }
  }

  @Override
  public void onError(CometChatException e) {
      Log.d(TAG, "Message fetching failed with exception: " + e.getMessage());
  }
});

val limit: Int = 30
val GUID: String = "cometchat-guid-1"

val messagesRequest = MessagesRequestBuilder()
  .setLimit(limit)
  .setGUID(GUID)
  .build()

messagesRequest.fetchPrevious(object : CallbackListener<List<BaseMessage?>>() {
  override fun onSuccess(list: List<BaseMessage?>) {
      for (message in list) {
          if (message is TextMessage) {
              Log.d(TAG, "Text message received successfully: $message")
          } else if (message is MediaMessage) {
              Log.d(TAG, "Media message received successfully: $message")
          }
      }
  }

  override fun onError(e: CometChatException) {
      Log.d(TAG, "Message fetching failed with exception: ${e.message}")
  }
})

Search Messages

Add setSearchKeyword() to the builder to filter messages by keyword.

One-on-One
Group

Java
Kotlin

private int limit = 30;
private String UID = "cometchat-uid-1";

MessagesRequest messagesRequest = new MessagesRequest.MessagesRequestBuilder().setSearchKeyword("Hello").setUID(UID).setLimit(limit).build();

messagesRequest.fetchPrevious(new CometChat.CallbackListener<List<BaseMessage>>() {
  @Override
  public void onSuccess(List<BaseMessage> list) {
      for (BaseMessage message : list) {
          if (message instanceof TextMessage) {
              Log.d(TAG, "Text message received successfully: " + ((TextMessage) message).toString());
          } else if (message instanceof MediaMessage) {
              Log.d(TAG, "Media message received successfully: " + ((MediaMessage)message).toString());
          }
      }
  }

  @Override
  public void onError(CometChatException e) {
      Log.d(TAG, "Message fetching failed with exception: " + e.getMessage());
  }
});

val limit: Int = 30
val UID: String = "cometchat-uid-1"

val messagesRequest = MessagesRequestBuilder().setSearchKeyword("Hello").setUID(UID).setLimit(limit).build()

messagesRequest.fetchPrevious(object : CallbackListener<List<BaseMessage?>>() {
  override fun onSuccess(list: List<BaseMessage?>) {
      for (message in list) {
          if (message is TextMessage) {
              Log.d(TAG, "Text message received successfully: $message")
          } else if (message is MediaMessage) {
              Log.d(TAG, "Media message received successfully: $message")
          }
      }
  }

  override fun onError(e: CometChatException) {
      Log.d(TAG, "Message fetching failed with exception: ${e.message}")
  }
})

Java
Kotlin

private int limit = 30;
private String GUID = "cometchat-guid-1";

MessagesRequest messagesRequest = new MessagesRequest.MessagesRequestBuilder().setSearchKeyword("Hello").setGUID(GUID).setLimit(limit).build();

messagesRequest.fetchPrevious(new CometChat.CallbackListener<List<BaseMessage>>() {
  @Override
  public void onSuccess(List<BaseMessage> list) {
      for (BaseMessage message : list) {
          if (message instanceof TextMessage) {
              Log.d(TAG, "Text message received successfully: " + ((TextMessage) message).toString());
          } else if (message instanceof MediaMessage) {
              Log.d(TAG, "Media message received successfully: " + ((MediaMessage)message).toString());
          }
      }
  }

  @Override
  public void onError(CometChatException e) {
      Log.d(TAG, "Message fetching failed with exception: " + e.getMessage());
  }
});

val limit = 30
val GUID = "cometchat-guid-1"

val messagesRequest = MessagesRequestBuilder().setSearchKeyword("Hello").setGUID(GUID).setLimit(limit).build()

messagesRequest.fetchPrevious(object : CallbackListener<List<BaseMessage?>>() {
  override fun onSuccess(list: List<BaseMessage?>) {
      for (message in list) {
          if (message is TextMessage) {
              Log.d(TAG, "Text message received successfully: $message")
          } else if (message is MediaMessage) {
              Log.d(TAG, "Media message received successfully: $message")
          }
      }
  }

  override fun onError(e: CometChatException) {
      Log.d(TAG, "Message fetching failed with exception: ${e.message}")
  }
})

Search Capabilities

By default, search only matches message text. With Conversation & Advanced Search enabled, it also matches file names, mentions, and MIME types.

Feature	Basic Search	Advanced Search
Text search	✅	✅
File name search	❌	✅
Mentions search	❌	✅
Mime type search	❌	✅

Conversation & Advanced Search is available on Advanced and Custom plans. Enable it from the CometChat Dashboard under Chats → Settings → General Configuration.

Unread Message Count

CometChat provides several methods to get unread counts at different scopes. All return results via a callback listener with a HashMap mapping IDs to counts. Each method accepts an optional boolean parameter to exclude messages from blocked users.

Method	Scope	Returns
`getUnreadMessageCountForUser(UID)`	Single user conversation	`HashMap<UID, count>`
`getUnreadMessageCountForGroup(GUID)`	Single group conversation	`HashMap<GUID, count>`
`getUnreadMessageCountForAllUsers()`	All user conversations	`HashMap<UID, count>`
`getUnreadMessageCountForAllGroups()`	All group conversations	`HashMap<GUID, count>`
`getUnreadMessageCount()`	Everything	`HashMap<"user"/"group", HashMap>`

Single Conversation

Java
Kotlin

// One-on-one
private String UID = "cometchat-uid-1";

CometChat.getUnreadMessageCountForUser(UID, new CometChat.CallbackListener<HashMap<String, Integer>>() {
  @Override
  public void onSuccess(HashMap<String, Integer> stringIntegerHashMap) {
      // handle success
  }

  @Override
  public void onError(CometChatException e) {
      // handle error
  }
});

// Group
private String GUID = "cometchat-guid-1";

CometChat.getUnreadMessageCountForGroup(GUID, new CometChat.CallbackListener<HashMap<String, Integer>>(){
  @Override
  public void onSuccess(HashMap<String, Integer> stringIntegerHashMap) {
      // handle success
  }

  @Override
  public void onError(CometChatException e) {
      // handle error
  }
});

// One-on-one
val UID: String = "cometchat-uid-1"

CometChat.getUnreadMessageCountForUser(UID, object : CallbackListener<HashMap<String?, Int?>?>() {
  override fun onSuccess(stringIntegerHashMap: HashMap<String?, Int?>?) {
      // handle success
  }

  override fun onError(e: CometChatException) {
      // handle error
  }
})

// Group
val GUID: String = "cometchat-guid-1"

CometChat.getUnreadMessageCountForGroup(GUID, object : CallbackListener<HashMap<String?, Int?>?>() {
  override fun onSuccess(stringIntegerHashMap: HashMap<String?, Int?>?) {
      // handle success
  }

  override fun onError(e: CometChatException) {
      // handle error
  }
})

All Conversations

Java
Kotlin

// All users and groups combined
CometChat.getUnreadMessageCount(new CometChat.CallbackListener<HashMap<String, HashMap<String, Integer>>>() {
  @Override
  public void onSuccess(HashMap<String, HashMap<String, Integer>> stringHashMapHashMap) {
      // handle success
  }

  @Override
  public void onError(CometChatException e) {
      // handle error
  }
});

// All user conversations only
CometChat.getUnreadMessageCountForAllUsers(new CometChat.CallbackListener<HashMap<String, Integer>>() {
  @Override
  public void onSuccess(HashMap<String, Integer> stringIntegerHashMap) {
      // Handle Success
  }

  @Override
  public void onError(CometChatException e) {
      // Handle Error
  }
});

// All group conversations only
CometChat.getUnreadMessageCountForAllGroups(new CometChat.CallbackListener<HashMap<String, Integer>>() {
  @Override
  public void onSuccess(HashMap<String, Integer> stringIntegerHashMap) {
      // Handle success
  }

  @Override
  public void onError(CometChatException e) {
      // Handle Error
  }
});

// All users and groups combined
CometChat.getUnreadMessageCount(object : CallbackListener<HashMap<String?, HashMap<String?, Int?>?>?>() {
  override fun onSuccess(stringHashMapHashMap: HashMap<String?, HashMap<String?, Int?>?>?) {
      // handle success
  }

  override fun onError(e: CometChatException) {
      // handle error
  }
})

// All user conversations only
CometChat.getUnreadMessageCountForAllUsers(object : CometChat.CallbackListener<HashMap<String, Int>>() {
  override fun onSuccess(stringIntegerHashMap: HashMap<String, Int>) {
      Log.d(TAG,"onSuccess: ${stringIntegerHashMap.size}")
  }

  override fun onError(e: CometChatException) {
      Log.d(TAG,"onError: ${e.message}")
  }
})

// All group conversations only
CometChat.getUnreadMessageCountForAllGroups(object : CometChat.CallbackListener<HashMap<String, Int>>() {
  override fun onSuccess(stringIntegerHashMap: HashMap<String, Int>) {
      Log.d(TAG,"onSuccess: ${stringIntegerHashMap.size}")
  }

  override fun onError(e: CometChatException) {
      Log.e(TAG,"onError: ${e.message}")
  }
})

Excluding Blocked Users

Pass true as the second argument to any of the methods above to ignore messages from blocked users:

Java
Kotlin

CometChat.getUnreadMessageCountForUser(UID, true, Callbacks);
CometChat.getUnreadMessageCountForGroup(GUID, true, Callbacks);
CometChat.getUnreadMessageCount(true, Callbacks);
CometChat.getUnreadMessageCountForAllUsers(true, Callbacks);
CometChat.getUnreadMessageCountForAllGroups(true, Callbacks);

CometChat.getUnreadMessageCountForUser(UID, true, Callbacks)
CometChat.getUnreadMessageCountForGroup(GUID, true, Callbacks)
CometChat.getUnreadMessageCount(true, Callbacks)
CometChat.getUnreadMessageCountForAllUsers(true, Callbacks)
CometChat.getUnreadMessageCountForAllGroups(true, Callbacks)

Get Message Details

Use getMessageDetails() to fetch a specific message by its ID. Returns the full message object (TextMessage, MediaMessage, CustomMessage, or other BaseMessage subclass).

Java
Kotlin

int messageId = MESSAGE_ID;

CometChat.getMessageDetails(messageId, new CometChat.CallbackListener<BaseMessage>() {
  @Override
  public void onSuccess(BaseMessage message) {
      Log.d(TAG, "Message details fetched: " + message.toString());
  }

  @Override
  public void onError(CometChatException e) {
      Log.d(TAG, "Error fetching message details: " + e.getMessage());
  }
});

val messageId: Int = MESSAGE_ID

CometChat.getMessageDetails(messageId, object : CometChat.CallbackListener<BaseMessage>() {
  override fun onSuccess(message: BaseMessage) {
      Log.d(TAG, "Message details fetched: $message")
  }

  override fun onError(e: CometChatException) {
      Log.d(TAG, "Error fetching message details: ${e.message}")
  }
})

Parameter	Type	Description
`messageId`	`int`	The ID of the message to fetch

Next Steps

Delivery & Read Receipts

Track when messages are delivered and read by recipients

Typing Indicators

Show real-time typing status in conversations

Message History

Advanced filtering options for message history

Send Message

Send text, media, and custom messages

Message Payload Structure

BaseMessage Object

The BaseMessage object returned by SDK methods contains the following fields. TextMessage, MediaMessage, and CustomMessage extend this base structure with additional type-specific fields.

Parameter	Type	Description
`id`	long	Unique message identifier
`muid`	String	Developer-defined message ID for deduplication
`sender`	User	User who sent the message
`receiver`	AppEntity	Message receiver (User or Group)
`receiverUid`	String	Receiver’s unique identifier
`type`	String	Message type. Values: `"text"`, `"image"`, `"video"`, `"audio"`, `"file"`, `"custom"`
`receiverType`	String	Type of receiver. Values: `"user"`, `"group"`
`category`	String	Message category. Values: `"message"`, `"action"`, `"call"`, `"custom"`
`sentAt`	long	Unix timestamp when message was sent
`deliveredAt`	long	Unix timestamp when message was delivered
`readAt`	long	Unix timestamp when message was read
`metadata`	JSONObject	Custom message metadata set by developer
`readByMeAt`	long	Unix timestamp when logged-in user read the message
`deliveredToMeAt`	long	Unix timestamp when message was delivered to logged-in user
`deletedAt`	long	Unix timestamp when message was deleted (0 if not deleted)
`editedAt`	long	Unix timestamp when message was edited (0 if not edited)
`deletedBy`	String	UID of user who deleted the message (null if not deleted)
`editedBy`	String	UID of user who edited the message (null if not edited)
`updatedAt`	long	Unix timestamp of last message update
`conversationId`	String	Associated conversation identifier
`parentMessageId`	long	Parent message ID for threaded messages (0 if not a reply)
`replyCount`	int	Number of replies in thread
`unreadRepliesCount`	int	Number of unread replies in thread
`mentionedUsers`	Array<User>	List of users mentioned in the message
`hasMentionedMe`	boolean	Whether the logged-in user is mentioned
`reactions`	Array<ReactionCount>	List of reaction counts on the message
`rawMessage`	JSONObject	Raw JSON message data
`quotedMessageId`	long	ID of the quoted message (0 if not quoting)
`quotedMessage`	BaseMessage	The quoted message object (null if not quoting)

Sample BaseMessage Object:

{
  "id": 12345,
  "muid": "msg_abc123",
  "sender": {
    "uid": "user_123",
    "name": "John Doe",
    "avatar": "https://example.com/avatar.png",
    "status": "online",
    "role": "default",
    "lastActiveAt": 1699900000
  },
  "receiver": {
    "uid": "user_456",
    "name": "Jane Smith",
    "avatar": "https://example.com/avatar2.png"
  },
  "receiverUid": "user_456",
  "type": "text",
  "receiverType": "user",
  "category": "message",
  "sentAt": 1699900000,
  "deliveredAt": 1699900001,
  "readAt": 1699900002,
  "metadata": {
    "priority": "high",
    "customField": "value"
  },
  "readByMeAt": 1699900002,
  "deliveredToMeAt": 1699900001,
  "deletedAt": 0,
  "editedAt": 0,
  "deletedBy": null,
  "editedBy": null,
  "updatedAt": 1699900000,
  "conversationId": "user_123_user_456",
  "parentMessageId": 0,
  "replyCount": 5,
  "unreadRepliesCount": 2,
  "mentionedUsers": [],
  "hasMentionedMe": false,
  "reactions": [
    {
      "reaction": "👍",
      "count": 3,
      "reactedByMe": true
    }
  ],
  "rawMessage": {},
  "quotedMessageId": 0,
  "quotedMessage": null
}

User Object

The nested User object (used in sender, receiver, mentionedUsers) 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)

Group Object

The nested Group object (used in receiver for group messages) contains:

Parameter	Type	Description
`guid`	String	Unique identifier of the group
`name`	String	Display name of the group
`type`	String	Group type. Values: `"public"`, `"private"`, `"password"`
`icon`	String	URL to group icon
`description`	String	Group description
`owner`	String	UID of group owner
`metadata`	JSONObject	Custom data set by developer
`membersCount`	int	Number of group members
`tags`	Array<String>	List of tags for group identification
`hasJoined`	boolean	Whether logged-in user has joined
`scope`	String	User’s scope in group. Values: `"admin"`, `"moderator"`, `"participant"`

ReactionCount Object

The nested ReactionCount object (used in reactions array) contains:

Parameter	Type	Description
`reaction`	String	The reaction emoji
`count`	int	Total count of this reaction
`reactedByMe`	boolean	Whether the logged-in user has reacted with this emoji

​Real-Time Messages

​Missed Messages

​Unread Messages

​Message History

​Search Messages

​Search Capabilities

​Unread Message Count

​Single Conversation

​All Conversations

​Excluding Blocked Users

​Get Message Details

​Next Steps

Delivery & Read Receipts

Typing Indicators

Message History

Send Message

​Message Payload Structure

Real-Time Messages

Missed Messages

Unread Messages

Message History

Search Messages

Search Capabilities

Unread Message Count

Single Conversation

All Conversations

Excluding Blocked Users

Get Message Details

Next Steps

Message Payload Structure