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

# Message Filtering

> Advanced filtering options for fetching messages using MessagesRequestBuilder in the CometChat React Native SDK.

<Accordion title="AI Integration Quick Reference">
  ```javascript theme={null}
  let parentId = 100;

  // Filter by category and type
  let mediaRequest = new CometChat.MessagesRequestBuilder()
    .setUID("UID")
    .setCategories(["message"])
    .setTypes(["image", "video", "audio", "file"])
    .setLimit(50)
    .build();

  // Unread messages only
  let unreadRequest = new CometChat.MessagesRequestBuilder()
    .setUID("UID")
    .setUnread(true)
    .setLimit(50)
    .build();

  // Threaded messages
  let threadRequest = new CometChat.MessagesRequestBuilder()
    .setUID("UID")
    .setParentMessageId(parentId)
    .setLimit(50)
    .build();

  // Fetch with pagination
  mediaRequest.fetchPrevious().then(messages => { });
  mediaRequest.fetchNext().then(messages => { });
  ```

  **Key methods:** `setUID()`, `setGUID()`, `setLimit()`, `setCategories()`, `setTypes()`, `setTags()`, `setUnread()`, `setParentMessageId()`, `setMessageId()`, `setTimestamp()`, `hideReplies()`, `hideDeletedMessages()`
</Accordion>

The `MessagesRequest` class fetches messages based on various parameters. It uses the Builder design pattern via `MessagesRequestBuilder`.

To fetch messages:

1. Create a `MessagesRequestBuilder` object
2. Set your desired parameters
3. Call `build()` to get a `MessagesRequest` object
4. Call `fetchNext()` or `fetchPrevious()` to retrieve messages

| Method            | Description                                      |
| ----------------- | ------------------------------------------------ |
| `fetchNext()`     | Returns messages after the specified parameters  |
| `fetchPrevious()` | Returns messages before the specified parameters |

Messages are paginated with a maximum of 100 per request. Call `fetchPrevious()`/`fetchNext()` repeatedly on the same object to get subsequent pages.

Both methods return an array of [`BaseMessage`](/sdk/reference/messages#basemessage) objects. Each message may be a [`TextMessage`](/sdk/reference/messages#textmessage), [`MediaMessage`](/sdk/reference/messages#mediamessage), [`CustomMessage`](/sdk/reference/messages#custommessage), [`Action`](/sdk/reference/messages#action), or [`Call`](/sdk/reference/messages#call). Use `instanceof` to check the type.

## Number of messages fetched

Set the number of messages to fetch per request using `setLimit()`. Maximum is 100.

<Tabs>
  <Tab title="TypeScript">
    ```typescript theme={null}
    let messagesRequest: CometChat.MessagesRequest =
      new CometChat.MessagesRequestBuilder().setLimit(50).build();
    ```
  </Tab>

  <Tab title="JavaScript">
    ```javascript theme={null}
    let messagesRequest = new CometChat.MessagesRequestBuilder()
      .setLimit(50)
      .build();
    ```
  </Tab>
</Tabs>

## Messages for a user conversation

Use `setUID()` to fetch messages between the logged-in user and a specific user.

<Tabs>
  <Tab title="TypeScript">
    ```typescript theme={null}
    let UID: string = "UID";
    let messagesRequest: CometChat.MessagesRequest =
      new CometChat.MessagesRequestBuilder().setUID(UID).setLimit(50).build();
    ```
  </Tab>

  <Tab title="JavaScript">
    ```javascript theme={null}
    let UID = "UID";
    let messagesRequest = new CometChat.MessagesRequestBuilder()
      .setUID(UID)
      .setLimit(50)
      .build();
    ```
  </Tab>
</Tabs>

When messages are fetched successfully, the response includes an array of message objects.

## Messages for a group conversation

Use `setGUID()` to fetch messages from a group. The logged-in user must be a member of the group.

<Tabs>
  <Tab title="TypeScript">
    ```typescript theme={null}
    let GUID: string = "GUID";
    let messagesRequest: CometChat.MessagesRequest =
      new CometChat.MessagesRequestBuilder().setGUID(GUID).setLimit(50).build();
    ```
  </Tab>

  <Tab title="JavaScript">
    ```javascript theme={null}
    let GUID = "GUID";
    let messagesRequest = new CometChat.MessagesRequestBuilder()
      .setGUID(GUID)
      .setLimit(50)
      .build();
    ```
  </Tab>
</Tabs>

When messages are fetched successfully, the response includes an array of message objects.

## Messages before/after a message

Use `setMessageId()` to fetch messages before or after a specific message ID. Use `fetchNext()` to get messages after, or `fetchPrevious()` to get messages before.

<Tabs>
  <Tab title="TypeScript (User)">
    ```typescript theme={null}
    let UID: string = "UID",
      messageId: number = 1,
      limit: number = 30,
      messagesRequest: CometChat.MessagesRequest =
        new CometChat.MessagesRequestBuilder()
          .setUID(UID)
          .setMessageId(messageId)
          .setLimit(limit)
          .build();
    ```
  </Tab>

  <Tab title="JavaScript (User)">
    ```javascript theme={null}
    let UID = "UID";
    let messageId = 1;
    let limit = 30;
    let messagesRequest = new CometChat.MessagesRequestBuilder()
      .setUID(UID)
      .setMessageId(messageId)
      .setLimit(limit)
      .build();
    ```
  </Tab>

  <Tab title="TypeScript (Group)">
    ```typescript theme={null}
    let GUID: string = "GUID",
      messageId: number = 1,
      limit: number = 30,
      messagesRequest: CometChat.MessagesRequest =
        new CometChat.MessagesRequestBuilder()
          .setGUID(GUID)
          .setMessageId(messageId)
          .setLimit(limit)
          .build();
    ```
  </Tab>

  <Tab title="JavaScript (Group)">
    ```javascript theme={null}
    let GUID = "GUID";
    let messageId = 1;
    let limit = 30;
    let messagesRequest = new CometChat.MessagesRequestBuilder()
      .setGUID(GUID)
      .setMessageId(messageId)
      .setLimit(limit)
      .build();
    ```
  </Tab>
</Tabs>

This method can be combined with `setUID()` or `setGUID()` to fetch messages around a specific message in a conversation.

## Messages before/after a given time

Use `setTimestamp()` with a Unix timestamp to fetch messages before or after a specific time.

<Tabs>
  <Tab title="TypeScript (User)">
    ```typescript theme={null}
    let UID: string = "UID",
      timestamp: number = 1602221371,
      limit: number = 30,
      messagesRequest: CometChat.MessagesRequest =
        new CometChat.MessagesRequestBuilder()
          .setUID(UID)
          .setTimestamp(timestamp)
          .setLimit(limit)
          .build();
    ```
  </Tab>

  <Tab title="JavaScript (User)">
    ```javascript theme={null}
    let UID = "UID";
    let timestamp = 1602221371;
    let limit = 30;
    let messagesRequest = new CometChat.MessagesRequestBuilder()
      .setUID(UID)
      .setTimestamp(timestamp)
      .setLimit(limit)
      .build();
    ```
  </Tab>

  <Tab title="TypeScript (Group)">
    ```typescript theme={null}
    let GUID: string = "GUID",
      timestamp: number = 1602221371,
      limit: number = 30,
      messagesRequest: CometChat.MessagesRequest =
        new CometChat.MessagesRequestBuilder()
          .setGUID(GUID)
          .setTimestamp(timestamp)
          .setLimit(limit)
          .build();
    ```
  </Tab>

  <Tab title="JavaScript (Group)">
    ```javascript theme={null}
    let GUID = "GUID";
    let timestamp = 1602221371;
    let limit = 30;
    let messagesRequest = new CometChat.MessagesRequestBuilder()
      .setGUID(GUID)
      .setTimestamp(timestamp)
      .setLimit(limit)
      .build();
    ```
  </Tab>
</Tabs>

This method can be combined with `setUID()` or `setGUID()` to fetch messages around a specific time in a conversation.

## Unread messages

Use `setUnread(true)` to fetch only unread messages.

<Tabs>
  <Tab title="TypeScript (User)">
    ```typescript theme={null}
    let UID: string = "UID",
      limit: number = 30,
      messagesRequest: CometChat.MessagesRequest =
        new CometChat.MessagesRequestBuilder()
          .setUID(UID)
          .setUnread(true)
          .setLimit(limit)
          .build();
    ```
  </Tab>

  <Tab title="JavaScript (User)">
    ```javascript theme={null}
    let UID = "UID";
    let limit = 30;
    let messagesRequest = new CometChat.MessagesRequestBuilder()
      .setUID(UID)
      .setUnread(true)
      .setLimit(limit)
      .build();
    ```
  </Tab>

  <Tab title="TypeScript (Group)">
    ```typescript theme={null}
    let GUID: string = "GUID",
      limit: number = 30,
      messagesRequest: CometChat.MessagesRequest =
        new CometChat.MessagesRequestBuilder()
          .setGUID(GUID)
          .setUnread(true)
          .setLimit(limit)
          .build();
    ```
  </Tab>

  <Tab title="JavaScript (Group)">
    ```javascript theme={null}
    let GUID = "GUID";
    let limit = 30;
    let messagesRequest = new CometChat.MessagesRequestBuilder()
      .setGUID(GUID)
      .setUnread(true)
      .setLimit(limit)
      .build();
    ```
  </Tab>
</Tabs>

Combine with `setGUID()` or `setUID()` to fetch unread messages for a specific conversation.

## Exclude messages from blocked users

Use `hideMessagesFromBlockedUsers(true)` to exclude messages from users you've blocked. Default is `false`.

<Tabs>
  <Tab title="TypeScript (User)">
    ```typescript theme={null}
    let UID: string = "UID",
      limit: number = 30,
      messagesRequest: CometChat.MessagesRequest =
        new CometChat.MessagesRequestBuilder()
          .setUID(UID)
          .hideMessagesFromBlockedUsers(true)
          .setLimit(limit)
          .build();
    ```
  </Tab>

  <Tab title="JavaScript (User)">
    ```javascript theme={null}
    let UID = "UID";
    let limit = 30;
    let messagesRequest = new CometChat.MessagesRequestBuilder()
      .setUID(UID)
      .hideMessagesFromBlockedUsers(true)
      .setLimit(limit)
      .build();
    ```
  </Tab>

  <Tab title="TypeScript (Group)">
    ```typescript theme={null}
    let GUID: string = "GUID",
      limit: number = 30,
      messagesRequest: CometChat.MessagesRequest =
        new CometChat.MessagesRequestBuilder()
          .setGUID(GUID)
          .hideMessagesFromBlockedUsers(true)
          .setLimit(limit)
          .build();
    ```
  </Tab>

  <Tab title="JavaScript (Group)">
    ```javascript theme={null}
    let GUID = "GUID";
    let limit = 30;
    let messagesRequest = new CometChat.MessagesRequestBuilder()
      .setGUID(GUID)
      .hideMessagesFromBlockedUsers(true)
      .setLimit(limit)
      .build();
    ```
  </Tab>
</Tabs>

This also works in group conversations where both users are members.

## Updated and received messages

Use `setUpdatedAfter()` with a Unix timestamp to fetch messages that were sent or updated after a specific time. Updated messages include those marked as read/delivered, edited, or deleted.

<Tabs>
  <Tab title="TypeScript (User)">
    ```typescript theme={null}
    let UID: string = "UID",
      limit: number = 30,
      timestamp: string = "1602221371",
      messagesRequest: CometChat.MessagesRequest =
        new CometChat.MessagesRequestBuilder()
          .setUID(UID)
          .setUpdatedAfter(timestamp)
          .setLimit(limit)
          .build();
    ```
  </Tab>

  <Tab title="JavaScript (User)">
    ```javascript theme={null}
    let UID = "UID";
    let limit = 30;
    let timestamp = 1602221371;
    let messagesRequest = new CometChat.MessagesRequestBuilder()
      .setUID(UID)
      .setUpdatedAfter(timestamp)
      .setLimit(limit)
      .build();
    ```
  </Tab>

  <Tab title="TypeScript (Group)">
    ```typescript theme={null}
    let GUID: string = "GUID",
      limit: number = 30,
      timestamp: string = "1602221371",
      messagesRequest: CometChat.MessagesRequest =
        new CometChat.MessagesRequestBuilder()
          .setGUID(GUID)
          .setUpdatedAfter(timestamp)
          .setLimit(limit)
          .build();
    ```
  </Tab>

  <Tab title="JavaScript (Group)">
    ```javascript theme={null}
    let GUID = "GUID";
    let limit = 30;
    let timestamp = 1602221371;
    let messagesRequest = new CometChat.MessagesRequestBuilder()
      .setGUID(GUID)
      .setUpdatedAfter(timestamp)
      .setLimit(limit)
      .build();
    ```
  </Tab>
</Tabs>

Useful for syncing messages with a local database — fetch only what's changed since your last sync.

## Updated messages only

Use `updatesOnly(true)` with `setUpdatedAfter()` to fetch only updated messages (not newly received ones). This method must be used together with `setUpdatedAfter()`.

<Tabs>
  <Tab title="TypeScript (User)">
    ```typescript theme={null}
    let UID: string = "UID",
      limit: number = 30,
      timestamp: string = "1602221371",
      messagesRequest: CometChat.MessagesRequest =
        new CometChat.MessagesRequestBuilder()
          .setUID(UID)
          .setUpdatedAfter(timestamp)
          .updatesOnly(true)
          .setLimit(limit)
          .build();
    ```
  </Tab>

  <Tab title="JavaScript (User)">
    ```javascript theme={null}
    let UID = "UID";
    let limit = 30;
    let timestamp = 1602221371;
    let messagesRequest = new CometChat.MessagesRequestBuilder()
      .setUID(UID)
      .setUpdatedAfter(timestamp)
      .updatesOnly(true)
      .setLimit(limit)
      .build();
    ```
  </Tab>

  <Tab title="TypeScript (Group)">
    ```typescript theme={null}
    let GUID: string = "GUID",
      limit: number = 30,
      timestamp: string = "1602221371",
      messagesRequest: CometChat.MessagesRequest =
        new CometChat.MessagesRequestBuilder()
          .setGUID(GUID)
          .setUpdatedAfter(timestamp)
          .updatesOnly(true)
          .setLimit(limit)
          .build();
    ```
  </Tab>

  <Tab title="JavaScript (Group)">
    ```javascript theme={null}
    let GUID = "GUID";
    let limit = 30;
    let timestamp = 1602221371;
    let messagesRequest = new CometChat.MessagesRequestBuilder()
      .setGUID(GUID)
      .setUpdatedAfter(timestamp)
      .updatesOnly(true)
      .setLimit(limit)
      .build();
    ```
  </Tab>
</Tabs>

When messages are fetched successfully, the response includes only messages that have been updated (edited, deleted, read/delivered status changed) after the specified timestamp.

## Messages for multiple categories

Use `setCategories()` with an array of category names to filter by message category. See [Message structure and hierarchy](/sdk/react-native/message-structure-and-hierarchy) for available categories.

<Tabs>
  <Tab title="TypeScript (User)">
    ```typescript theme={null}
    let UID: string = "UID",
      limit: number = 30,
      categories: Array<String> = ["message", "custom"],
      messagesRequest: CometChat.MessagesRequest =
        new CometChat.MessagesRequestBuilder()
          .setUID(UID)
          .setCategories(categories)
          .setLimit(limit)
          .build();
    ```
  </Tab>

  <Tab title="JavaScript (User)">
    ```javascript theme={null}
    let UID = "UID";
    let limit = 30;
    let categories = ["message", "custom"];
    let messagesRequest = new CometChat.MessagesRequestBuilder()
      .setUID(UID)
      .setCategories(categories)
      .setLimit(limit)
      .build();
    ```
  </Tab>

  <Tab title="TypeScript (Group)">
    ```typescript theme={null}
    let GUID: string = "GUID",
      limit: number = 30,
      categories: Array<String> = ["message", "custom"],
      messagesRequest: CometChat.MessagesRequest =
        new CometChat.MessagesRequestBuilder()
          .setGUID(GUID)
          .setCategories(categories)
          .setLimit(limit)
          .build();
    ```
  </Tab>

  <Tab title="JavaScript (Group)">
    ```javascript theme={null}
    let GUID = "GUID";
    let limit = 30;
    let categories = ["message", "custom"];
    let messagesRequest = new CometChat.MessagesRequestBuilder()
      .setGUID(GUID)
      .setCategories(categories)
      .setLimit(limit)
      .build();
    ```
  </Tab>
</Tabs>

The above snippet fetches only messages in the `message` and `custom` categories. Use this to exclude categories like `call` and `action`.

## Messages for multiple types

Use `setTypes()` with an array of type names to filter by message type. See [Message structure and hierarchy](/sdk/react-native/message-structure-and-hierarchy) for available types.

<Tabs>
  <Tab title="TypeScript (User)">
    ```typescript theme={null}
    let UID: string = "UID",
      limit: number = 30,
      categories: Array<String> = ["message", "custom"],
      types: Array<String> = ["image", "video", "audio", "file"],
      messagesRequest: CometChat.MessagesRequest =
        new CometChat.MessagesRequestBuilder()
          .setUID(UID)
          .setCategories(categories)
          .setTypes(types)
          .setLimit(limit)
          .build();
    ```
  </Tab>

  <Tab title="JavaScript (User)">
    ```javascript theme={null}
    let UID = "UID";
    let limit = 30;
    let categories = ["message"];
    let types = ["image", "video", "audio", "file"];
    let messagesRequest = new CometChat.MessagesRequestBuilder()
      .setUID(UID)
      .setCategories(categories)
      .setTypes(types)
      .setLimit(limit)
      .build();
    ```
  </Tab>

  <Tab title="TypeScript (Group)">
    ```typescript theme={null}
    let GUID: string = "GUID",
      limit: number = 30,
      categories: Array<String> = ["message", "custom"],
      types: Array<String> = ["image", "video", "audio", "file"],
      messagesRequest: CometChat.MessagesRequest =
        new CometChat.MessagesRequestBuilder()
          .setGUID(GUID)
          .setCategories(categories)
          .setTypes(types)
          .setLimit(limit)
          .build();
    ```
  </Tab>

  <Tab title="JavaScript (Group)">
    ```javascript theme={null}
    let GUID = "GUID";
    let limit = 30;
    let categories = ["message"];
    let types = ["image", "video", "audio", "file"];
    let messagesRequest = new CometChat.MessagesRequestBuilder()
      .setGUID(GUID)
      .setCategories(categories)
      .setTypes(types)
      .setLimit(limit)
      .build();
    ```
  </Tab>
</Tabs>

The above snippet fetches all media messages (image, video, audio, file).

## Messages for a specific thread

Use `setParentMessageId()` to fetch messages belonging to a specific thread.

<Tabs>
  <Tab title="TypeScript (User)">
    ```typescript theme={null}
    let UID: string = "UID",
      limit: number = 30,
      messageId: number = 1,
      messagesRequest: CometChat.MessagesRequest =
        new CometChat.MessagesRequestBuilder()
          .setUID(UID)
          .setLimit(limit)
          .setParentMessageId(messageId)
          .build();
    ```
  </Tab>

  <Tab title="JavaScript (User)">
    ```javascript theme={null}
    let UID = "UID";
    let messageId = 1;
    let limit = 30;
    let messagesRequest = new CometChat.MessagesRequestBuilder()
      .setUID(UID)
      .setLimit(limit)
      .setParentMessageId(messageId)
      .build();
    ```
  </Tab>

  <Tab title="TypeScript (Group)">
    ```typescript theme={null}
    let GUID: string = "GUID",
      limit: number = 30,
      messageId: number = 1,
      messagesRequest: CometChat.MessagesRequest =
        new CometChat.MessagesRequestBuilder()
          .setGUID(GUID)
          .setLimit(limit)
          .setParentMessageId(messageId)
          .build();
    ```
  </Tab>

  <Tab title="JavaScript (Group)">
    ```javascript theme={null}
    let GUID = "GUID";
    let messageId = 1;
    let limit = 30;
    let messagesRequest = new CometChat.MessagesRequestBuilder()
      .setGUID(GUID)
      .setLimit(limit)
      .setParentMessageId(messageId)
      .build();
    ```
  </Tab>
</Tabs>

The above code returns messages belonging to the thread with the specified parent message ID.

## Hide threaded messages in user/group conversations

Use `hideReplies(true)` to exclude threaded messages from the main conversation. Default is `false`.

<Tabs>
  <Tab title="TypeScript (User)">
    ```typescript theme={null}
    let UID: string = "UID",
      limit: number = 30,
      messagesRequest: CometChat.MessagesRequest =
        new CometChat.MessagesRequestBuilder()
          .setUID(UID)
          .setLimit(limit)
          .hideReplies(true)
          .build();
    ```
  </Tab>

  <Tab title="JavaScript (User)">
    ```javascript theme={null}
    let UID = "UID";
    let limit = 30;
    let messagesRequest = new CometChat.MessagesRequestBuilder()
      .setUID(UID)
      .setLimit(limit)
      .hideReplies(true)
      .build();
    ```
  </Tab>

  <Tab title="TypeScript (Group)">
    ```typescript theme={null}
    let GUID: string = "GUID",
      limit: number = 30,
      messagesRequest: CometChat.MessagesRequest =
        new CometChat.MessagesRequestBuilder()
          .setGUID(GUID)
          .setLimit(limit)
          .hideReplies(true)
          .build();
    ```
  </Tab>

  <Tab title="JavaScript (Group)">
    ```javascript theme={null}
    let GUID = "GUID";
    let limit = 30;
    let messagesRequest = new CometChat.MessagesRequestBuilder()
      .setGUID(GUID)
      .setLimit(limit)
      .hideReplies(true)
      .build();
    ```
  </Tab>
</Tabs>

## Hide deleted messages in user/group conversations

Use `hideDeletedMessages(true)` to exclude deleted messages. Default is `false`.

<Tabs>
  <Tab title="TypeScript (User)">
    ```typescript theme={null}
    let UID: string = "UID",
      limit: number = 30,
      messagesRequest: CometChat.MessagesRequest =
        new CometChat.MessagesRequestBuilder()
          .setUID(UID)
          .setLimit(limit)
          .hideDeletedMessages(true)
          .build();
    ```
  </Tab>

  <Tab title="JavaScript (User)">
    ```javascript theme={null}
    let UID = "UID";
    let limit = 30;
    let messagesRequest = new CometChat.MessagesRequestBuilder()
      .setUID(UID)
      .setLimit(limit)
      .hideDeletedMessages(true)
      .build();
    ```
  </Tab>

  <Tab title="TypeScript (Group)">
    ```typescript theme={null}
    let GUID: string = "GUID",
      limit: number = 30,
      messagesRequest: CometChat.MessagesRequest =
        new CometChat.MessagesRequestBuilder()
          .setGUID(GUID)
          .setLimit(limit)
          .hideDeletedMessages(true)
          .build();
    ```
  </Tab>

  <Tab title="JavaScript (Group)">
    ```javascript theme={null}
    let GUID = "GUID";
    let limit = 30;
    let messagesRequest = new CometChat.MessagesRequestBuilder()
      .setGUID(GUID)
      .setLimit(limit)
      .hideDeletedMessages(true)
      .build();
    ```
  </Tab>
</Tabs>

## Hide quoted messages in user/group conversations

Use `hideQuotedMessages(true)` to exclude quoted messages. Default is `false`.

<Tabs>
  <Tab title="TypeScript (User)">
    ```typescript theme={null}
    let UID: string = "UID",
      limit: number = 30,
      messagesRequest: CometChat.MessagesRequest =
        new CometChat.MessagesRequestBuilder()
          .setUID(UID)
          .setLimit(limit)
          .hideQuotedMessages(true)
          .build();
    ```
  </Tab>

  <Tab title="JavaScript (User)">
    ```javascript theme={null}
    let UID = "UID";
    let limit = 30;
    let messagesRequest = new CometChat.MessagesRequestBuilder()
      .setUID(UID)
      .setLimit(limit)
      .hideQuotedMessages(true)
      .build();
    ```
  </Tab>

  <Tab title="TypeScript (Group)">
    ```typescript theme={null}
    let GUID: string = "GUID",
      limit: number = 30,
      messagesRequest: CometChat.MessagesRequest =
        new CometChat.MessagesRequestBuilder()
          .setGUID(GUID)
          .setLimit(limit)
          .hideQuotedMessages(true)
          .build();
    ```
  </Tab>

  <Tab title="JavaScript (Group)">
    ```javascript theme={null}
    let GUID = "GUID";
    let limit = 30;
    let messagesRequest = new CometChat.MessagesRequestBuilder()
      .setGUID(GUID)
      .setLimit(limit)
      .hideQuotedMessages(true)
      .build();
    ```
  </Tab>
</Tabs>

## Messages by tags

Use `setTags()` with an array of tag names to fetch only messages with those tags.

<Tabs>
  <Tab title="TypeScript (User)">
    ```typescript theme={null}
    let UID: string = "UID",
      limit: number = 30,
      tags: Array<String> = ["starredMessage"],
      messagesRequest: CometChat.MessagesRequest =
        new CometChat.MessagesRequestBuilder()
          .setUID(UID)
          .setLimit(limit)
          .setTags(tags)
          .build();
    ```
  </Tab>

  <Tab title="JavaScript (User)">
    ```javascript theme={null}
    let UID = "UID";
    let limit = 30;
    let tags = ["starredMessage"];
    let messagesRequest = new CometChat.MessagesRequestBuilder()
      .setUID(UID)
      .setLimit(limit)
      .setTags(tags)
      .build();
    ```
  </Tab>

  <Tab title="TypeScript (Group)">
    ```typescript theme={null}
    let GUID: string = "GUID",
      limit: number = 30,
      tags: Array<String> = ["starredMessage"],
      messagesRequest: CometChat.MessagesRequest =
        new CometChat.MessagesRequestBuilder()
          .setGUID(GUID)
          .setLimit(limit)
          .setTags(tags)
          .build();
    ```
  </Tab>

  <Tab title="JavaScript (Group)">
    ```javascript theme={null}
    let GUID = "GUID";
    let limit = 30;
    let tags = ["starredMessage"];
    let messagesRequest = new CometChat.MessagesRequestBuilder()
      .setGUID(GUID)
      .setLimit(limit)
      .setTags(tags)
      .build();
    ```
  </Tab>
</Tabs>

## Messages with tags

Use `withTags(true)` to include tag information in the response. Default is `false`.

<Tabs>
  <Tab title="TypeScript (User)">
    ```typescript theme={null}
    let UID: string = "UID",
      limit: number = 30,
      messagesRequest: CometChat.MessagesRequest =
        new CometChat.MessagesRequestBuilder()
          .setUID(UID)
          .setLimit(limit)
          .withTags(true)
          .build();
    ```
  </Tab>

  <Tab title="JavaScript (User)">
    ```javascript theme={null}
    let UID = "UID";
    let limit = 30;
    let messagesRequest = new CometChat.MessagesRequestBuilder()
      .setUID(UID)
      .setLimit(limit)
      .withTags(true)
      .build();
    ```
  </Tab>

  <Tab title="TypeScript (Group)">
    ```typescript theme={null}
    let GUID: string = "GUID",
      limit: number = 30,
      messagesRequest: CometChat.MessagesRequest =
        new CometChat.MessagesRequestBuilder()
          .setGUID(GUID)
          .setLimit(limit)
          .withTags(true)
          .build();
    ```
  </Tab>

  <Tab title="JavaScript (Group)">
    ```javascript theme={null}
    let GUID = "GUID";
    let limit = 30;
    let messagesRequest = new CometChat.MessagesRequestBuilder()
      .setGUID(GUID)
      .setLimit(limit)
      .withTags(true)
      .build();
    ```
  </Tab>
</Tabs>

When `withTags(true)` is set, each message's `tags` field will be populated. Access tags using `getTags()`.

| Additional Field | Getter      | Return Type | Description                      |
| ---------------- | ----------- | ----------- | -------------------------------- |
| tags             | `getTags()` | `string[]`  | Tags associated with the message |

## Messages with links

Use `hasLinks(true)` to fetch only messages containing links. Default is `false`.

<Note>
  This feature is only available with `Conversation & Advanced Search`. The `Conversation & Advanced Search` is only available in `Advanced` & `Custom` [plans](https://www.cometchat.com/pricing). If you're already on one of these plans, please enable the `Conversation & Advanced Search` from [CometChat Dashboard](https://app.cometchat.com) (Open your app, navigate to Chats -> Settings -> General Configuration)
</Note>

<Tabs>
  <Tab title="TypeScript (User)">
    ```typescript theme={null}
    let UID: string = "UID",
      limit: number = 30,
      messagesRequest: CometChat.MessagesRequest =
        new CometChat.MessagesRequestBuilder()
          .setUID(UID)
          .setLimit(limit)
          .hasLinks(true)
          .build();
    ```
  </Tab>

  <Tab title="JavaScript (User)">
    ```javascript theme={null}
    let UID = "UID";
    let limit = 30;
    let messagesRequest = new CometChat.MessagesRequestBuilder()
      .setUID(UID)
      .setLimit(limit)
      .hasLinks(true)
      .build();
    ```
  </Tab>

  <Tab title="TypeScript (Group)">
    ```typescript theme={null}
    let GUID: string = "GUID",
      limit: number = 30,
      messagesRequest: CometChat.MessagesRequest =
        new CometChat.MessagesRequestBuilder()
          .setGUID(GUID)
          .setLimit(limit)
          .hasLinks(true)
          .build();
    ```
  </Tab>

  <Tab title="JavaScript (Group)">
    ```javascript theme={null}
    let GUID = "GUID";
    let limit = 30;
    let messagesRequest = new CometChat.MessagesRequestBuilder()
      .setGUID(GUID)
      .setLimit(limit)
      .hasLinks(true)
      .build();
    ```
  </Tab>
</Tabs>

## Messages with attachments

Use `hasAttachments(true)` to fetch only messages with attachments (image, audio, video, or file). Default is `false`.

<Note>
  This feature is only available with `Conversation & Advanced Search`. The `Conversation & Advanced Search` is only available in `Advanced` & `Custom` [plans](https://www.cometchat.com/pricing). If you're already on one of these plans, please enable the `Conversation & Advanced Search` from [CometChat Dashboard](https://app.cometchat.com) (Open your app, navigate to Chats -> Settings -> General Configuration)
</Note>

<Tabs>
  <Tab title="TypeScript (User)">
    ```typescript theme={null}
    let UID: string = "UID",
      limit: number = 30,
      messagesRequest: CometChat.MessagesRequest =
        new CometChat.MessagesRequestBuilder()
          .setUID(UID)
          .setLimit(limit)
          .hasAttachments(true)
          .build();
    ```
  </Tab>

  <Tab title="JavaScript (User)">
    ```javascript theme={null}
    let UID = "UID";
    let limit = 30;
    let messagesRequest = new CometChat.MessagesRequestBuilder()
      .setUID(UID)
      .setLimit(limit)
      .hasAttachments(true)
      .build();
    ```
  </Tab>

  <Tab title="TypeScript (Group)">
    ```typescript theme={null}
    let GUID: string = "GUID",
      limit: number = 30,
      messagesRequest: CometChat.MessagesRequest =
        new CometChat.MessagesRequestBuilder()
          .setGUID(GUID)
          .setLimit(limit)
          .hasAttachments(true)
          .build();
    ```
  </Tab>

  <Tab title="JavaScript (Group)">
    ```javascript theme={null}
    let GUID = "GUID";
    let limit = 30;
    let messagesRequest = new CometChat.MessagesRequestBuilder()
      .setGUID(GUID)
      .setLimit(limit)
      .hasAttachments(true)
      .build();
    ```
  </Tab>
</Tabs>

The response contains media message objects with attachment details including file metadata and thumbnail URLs.

## Messages with reactions

Use `hasReactions(true)` to fetch only messages that have reactions. Default is `false`.

<Note>
  This feature is only available with `Conversation & Advanced Search`. The `Conversation & Advanced Search` is only available in `Advanced` & `Custom` [plans](https://www.cometchat.com/pricing). If you're already on one of these plans, please enable the `Conversation & Advanced Search` from [CometChat Dashboard](https://app.cometchat.com) (Open your app, navigate to Chats -> Settings -> General Configuration)
</Note>

<Tabs>
  <Tab title="TypeScript (User)">
    ```typescript theme={null}
    let UID: string = "UID",
      limit: number = 30,
      messagesRequest: CometChat.MessagesRequest =
        new CometChat.MessagesRequestBuilder()
          .setUID(UID)
          .setLimit(limit)
          .hasReactions(true)
          .build();
    ```
  </Tab>

  <Tab title="JavaScript (User)">
    ```javascript theme={null}
    let UID = "UID";
    let limit = 30;
    let messagesRequest = new CometChat.MessagesRequestBuilder()
      .setUID(UID)
      .setLimit(limit)
      .hasReactions(true)
      .build();
    ```
  </Tab>

  <Tab title="TypeScript (Group)">
    ```typescript theme={null}
    let GUID: string = "GUID",
      limit: number = 30,
      messagesRequest: CometChat.MessagesRequest =
        new CometChat.MessagesRequestBuilder()
          .setGUID(GUID)
          .setLimit(limit)
          .hasReactions(true)
          .build();
    ```
  </Tab>

  <Tab title="JavaScript (Group)">
    ```javascript theme={null}
    let GUID = "GUID";
    let limit = 30;
    let messagesRequest = new CometChat.MessagesRequestBuilder()
      .setGUID(GUID)
      .setLimit(limit)
      .hasReactions(true)
      .build();
    ```
  </Tab>
</Tabs>

The response contains message objects with reactions. Each message's `data` object includes a `reactions` array.

## Messages with mentions

Use `hasMentions(true)` to fetch only messages that contain mentions. Default is `false`.

<Note>
  This feature is only available with `Conversation & Advanced Search`. The `Conversation & Advanced Search` is only available in `Advanced` & `Custom` [plans](https://www.cometchat.com/pricing). If you're already on one of these plans, please enable the `Conversation & Advanced Search` from [CometChat Dashboard](https://app.cometchat.com) (Open your app, navigate to Chats -> Settings -> General Configuration)
</Note>

<Tabs>
  <Tab title="TypeScript (User)">
    ```typescript theme={null}
    let UID: string = "UID",
      limit: number = 30,
      messagesRequest: CometChat.MessagesRequest =
        new CometChat.MessagesRequestBuilder()
          .setUID(UID)
          .setLimit(limit)
          .hasMentions(true)
          .build();
    ```
  </Tab>

  <Tab title="JavaScript (User)">
    ```javascript theme={null}
    let UID = "UID";
    let limit = 30;
    let messagesRequest = new CometChat.MessagesRequestBuilder()
      .setUID(UID)
      .setLimit(limit)
      .hasMentions(true)
      .build();
    ```
  </Tab>

  <Tab title="TypeScript (Group)">
    ```typescript theme={null}
    let GUID: string = "GUID",
      limit: number = 30,
      messagesRequest: CometChat.MessagesRequest =
        new CometChat.MessagesRequestBuilder()
          .setGUID(GUID)
          .setLimit(limit)
          .hasMentions(true)
          .build();
    ```
  </Tab>

  <Tab title="JavaScript (Group)">
    ```javascript theme={null}
    let GUID = "GUID";
    let limit = 30;
    let messagesRequest = new CometChat.MessagesRequestBuilder()
      .setGUID(GUID)
      .setLimit(limit)
      .hasMentions(true)
      .build();
    ```
  </Tab>
</Tabs>

The response contains text message objects with mentions. Each message has a `mentionedUsers` array, a `mentionedMe` boolean, and a `data.mentions` object.

## Messages with particular user mentions

Use `setMentionedUIDs()` with an array of UIDs to fetch messages that mention specific users.

<Note>
  This feature is only available with `Conversation & Advanced Search`. The `Conversation & Advanced Search` is only available in `Advanced` & `Custom` [plans](https://www.cometchat.com/pricing). If you're already on one of these plans, please enable the `Conversation & Advanced Search` from [CometChat Dashboard](https://app.cometchat.com) (Open your app, navigate to Chats -> Settings -> General Configuration)
</Note>

<Tabs>
  <Tab title="TypeScript (User)">
    ```typescript theme={null}
    let UID: string = "UID",
      limit: number = 30,
      messagesRequest: CometChat.MessagesRequest =
        new CometChat.MessagesRequestBuilder()
          .setUID(UID)
          .setLimit(limit)
          .setMentionedUIDs(["UID"])
          .build();
    ```
  </Tab>

  <Tab title="JavaScript (User)">
    ```javascript theme={null}
    let UID = "UID";
    let limit = 30;
    let messagesRequest = new CometChat.MessagesRequestBuilder()
      .setUID(UID)
      .setLimit(limit)
      .setMentionedUIDs(["UID"])
      .build();
    ```
  </Tab>

  <Tab title="TypeScript (Group)">
    ```typescript theme={null}
    let GUID: string = "GUID",
      limit: number = 30,
      messagesRequest: CometChat.MessagesRequest =
        new CometChat.MessagesRequestBuilder()
          .setGUID(GUID)
          .setLimit(limit)
          .setMentionedUIDs(["UID"])
          .build();
    ```
  </Tab>

  <Tab title="JavaScript (Group)">
    ```javascript theme={null}
    let GUID = "GUID";
    let limit = 30;
    let messagesRequest = new CometChat.MessagesRequestBuilder()
      .setGUID(GUID)
      .setLimit(limit)
      .setMentionedUIDs(["UID"])
      .build();
    ```
  </Tab>
</Tabs>

The response contains text message objects that mention the specified users.

## Messages with specific attachment types

Use `setAttachmentTypes()` with an array of `CometChat.AttachmentType` values to fetch messages with specific attachment types.

<Note>
  This feature is only available with `Conversation & Advanced Search`. The `Conversation & Advanced Search` is only available in `Advanced` & `Custom` [plans](https://www.cometchat.com/pricing). If you're already on one of these plans, please enable the `Conversation & Advanced Search` from [CometChat Dashboard](https://app.cometchat.com) (Open your app, navigate to Chats -> Settings -> General Configuration)
</Note>

<Tabs>
  <Tab title="TypeScript (User)">
    ```typescript theme={null}
    let UID: string = "UID",
      limit: number = 30,
      messagesRequest: CometChat.MessagesRequest =
        new CometChat.MessagesRequestBuilder()
          .setUID(UID)
          .setLimit(limit)
          .setAttachmentTypes([CometChat.AttachmentType.IMAGE, CometChat.AttachmentType.VIDEO])
          .build();
    ```
  </Tab>

  <Tab title="JavaScript (User)">
    ```javascript theme={null}
    let UID = "UID";
    let limit = 30;
    let messagesRequest = new CometChat.MessagesRequestBuilder()
      .setUID(UID)
      .setLimit(limit)
      .setAttachmentTypes([CometChat.AttachmentType.IMAGE, CometChat.AttachmentType.VIDEO])
      .build();
    ```
  </Tab>

  <Tab title="TypeScript (Group)">
    ```typescript theme={null}
    let GUID: string = "GUID",
      limit: number = 30,
      messagesRequest: CometChat.MessagesRequest =
        new CometChat.MessagesRequestBuilder()
          .setGUID(GUID)
          .setLimit(limit)
          .setAttachmentTypes([CometChat.AttachmentType.IMAGE, CometChat.AttachmentType.VIDEO])
          .build();
    ```
  </Tab>

  <Tab title="JavaScript (Group)">
    ```javascript theme={null}
    let GUID = "GUID";
    let limit = 30;
    let messagesRequest = new CometChat.MessagesRequestBuilder()
      .setGUID(GUID)
      .setLimit(limit)
      .setAttachmentTypes([CometChat.AttachmentType.IMAGE, CometChat.AttachmentType.VIDEO])
      .build();
    ```
  </Tab>
</Tabs>

The response contains media message objects filtered to the specified attachment types.

## Next Steps

<CardGroup cols={2}>
  <Card title="Send Messages" icon="paper-plane" href="/sdk/react-native/send-message">
    Send text, media, and custom messages
  </Card>

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

  <Card title="Message Structure" icon="sitemap" href="/sdk/react-native/message-structure-and-hierarchy">
    Understand message categories, types, and hierarchy
  </Card>

  <Card title="Threaded Messages" icon="comments" href="/sdk/react-native/threaded-messages">
    Work with threaded conversations
  </Card>
</CardGroup>