Save A Message

Save and unsave messages privately, fetch the saved list across conversations, and listen for save events with the CometChat React Native SDK.

AI Integration Quick Reference

// Save / unsave a message
const saved = await CometChat.saveMessage(messageId);
const unsaved = await CometChat.unsaveMessage(messageId);

// Fetch the saved list — user-level, so NO setUID()/setGUID()
const request = new CometChat.MessagesRequestBuilder()
  .setSavedOnly(true)
  .setLimit(50)
  .build();
const messages = await request.fetchPrevious();

// Read save state off a message — there is no isSaved()
const isSaved = message.getSavedAt() !== undefined;

// Cap and availability
const limit = await CometChat.getSaveMessageLimit();      // number | null
const enabled = await CometChat.isSaveMessageEnabled();   // boolean

Saving bookmarks a message for the logged-in user. Unlike a pin, a save is private and cross-conversation: nobody else can see it, no role is required, and the saved list spans every conversation the user is part of.

savedAt is per-viewer. It is only ever populated in the acting user’s own context — you will never see another user’s saves on a message, so the same message reads saved for one user and unsaved for everyone else.

​

Save a Message

Call saveMessage() with the message’s ID. It resolves with the full updated message, with savedAt set.

TypeScript

let messageId: number = 100;

CometChat.saveMessage(messageId).then(
  (message: CometChat.BaseMessage) => {
    console.log("Message saved:", message);
  },
  (error: CometChat.CometChatException) => {
    console.log("Failed to save message:", error);
  }
);

JavaScript

let messageId = 100;

CometChat.saveMessage(messageId).then(
  (message) => {
    console.log("Message saved:", message);
  },
  (error) => {
    console.log("Failed to save message:", error);
  }
);

Saving is idempotent — saving an already saved message succeeds rather than failing. There is no role gate. On a cap breach the rejection carries the server-owned ceiling in errorParams.limit.

A just-sent message may not be pinnable or savable yet. On an app with moderation enabled, the server stamps a new message moderation.status: "pending" and clears it to "approved" a moment later. While it is pending, saveMessage() rejects with 403 ERR_MESSAGE_NO_ACCESS — the same code it returns for a genuine permission refusal, so you cannot tell the two apart from the error alone.

Measured on a moderated app, the window runs from send, not from the user’s tap, and clears within a few seconds. Do not disable the control on this error: by the time someone opens a menu and taps, moderation has usually finished. Prefer a retry or a transient “not ready yet” message over telling the user they lack permission. Moderation is configured per app, so this never reproduces on an app that has it switched off.

​

Unsave a Message

TypeScript

CometChat.unsaveMessage(100).then(
  (message: CometChat.BaseMessage) => {
    console.log("Message unsaved:", message);
  },
  (error: CometChat.CometChatException) => {
    console.log("Failed to unsave message:", error);
  }
);

JavaScript

CometChat.unsaveMessage(100).then(
  (message) => {
    console.log("Message unsaved:", message);
  },
  (error) => {
    console.log("Failed to unsave message:", error);
  }
);

The resolved message comes back with savedAt cleared, never left stale.

​

Fetch Saved Messages

Build a MessagesRequest with setSavedOnly(true). The saved list is user-level, so unlike the pinned list you do not set a UID or a GUID — leaving both unset is what makes it cross-conversation.

TypeScript

let messagesRequest: CometChat.MessagesRequest =
  new CometChat.MessagesRequestBuilder()
    .setSavedOnly(true)
    .setLimit(50)
    .build();

messagesRequest.fetchPrevious().then(
  (messages: CometChat.BaseMessage[]) => {
    console.log("Saved messages:", messages);
  },
  (error: CometChat.CometChatException) => {
    console.log("Failed to fetch saved messages:", error);
  }
);

JavaScript

let messagesRequest = new CometChat.MessagesRequestBuilder()
  .setSavedOnly(true)
  .setLimit(50)
  .build();

messagesRequest.fetchPrevious().then(
  (messages) => {
    console.log("Saved messages:", messages);
  },
  (error) => {
    console.log("Failed to fetch saved messages:", error);
  }
);

The default value for setLimit is 30 and the max value is 100.

The list comes back newest save first. Call fetchPrevious() again on the same object to page through older entries — this filter changes what the list contains, not how it pages.

Do not combine setSavedOnly(true) with setUID() or setGUID(). Saves are account-wide; adding a scope narrows the list to one conversation and quietly hides the rest.

Because the list spans conversations, every row carries its own context — use getConversationId(), getReceiverId() and getReceiverType() to route a tap on a saved message back to the right conversation.

TypeScript

messages.forEach((message: CometChat.BaseMessage) => {
  console.log(
    message.getConversationId(),
    message.getReceiverType(), // "user" or "group"
    message.getReceiverId()
  );
});

JavaScript

messages.forEach((message) => {
  console.log(
    message.getConversationId(),
    message.getReceiverType(), // "user" or "group"
    message.getReceiverId()
  );
});

​

Check if a Message is Saved

The React Native SDK has no isSaved() helper — the presence of savedAt is the boolean, and an unsaved message simply has no save attribute.

TypeScript

const isSaved: boolean = message.getSavedAt() !== undefined;

if (isSaved) {
  console.log("Saved at:", message.getSavedAt());
}

JavaScript

const isSaved = message.getSavedAt() !== undefined;

if (isSaved) {
  console.log("Saved at:", message.getSavedAt());
}

Method	Returns
getSavedAt()	The save timestamp, or undefined when the user has not saved it.

Do not port isSaved() from the JavaScript SDK — it does not exist in the React Native SDK. Derive it from getSavedAt() as shown above.

​

Real-time Save Events

Save and unsave are private multi-device events: they are delivered to the user’s other logged-in sessions so a save on the phone shows up on the desktop. Add the callbacks to your existing MessageListener.

TypeScript

CometChat.addMessageListener(
  "UNIQUE_LISTENER_ID",
  new CometChat.MessageListener({
    onMessageSaved: (message: CometChat.BaseMessage) => {
      console.log("Message saved:", message);
    },
    onMessageUnsaved: (message: CometChat.BaseMessage) => {
      console.log("Message unsaved:", message);
    },
  })
);

JavaScript

CometChat.addMessageListener(
  "UNIQUE_LISTENER_ID",
  new CometChat.MessageListener({
    onMessageSaved: (message) => {
      console.log("Message saved:", message);
    },
    onMessageUnsaved: (message) => {
      console.log("Message unsaved:", message);
    },
  })
);

These callbacks fire for saves made on your other devices, not the one that performed the save — that device already has the message resolved from saveMessage(). Update your saved list from the promise there, and from these callbacks everywhere else.

​

Save Limit

A user may save a capped number of messages across all conversations. Read the cap from app settings rather than hard-coding it.

TypeScript

let limit: number | null = await CometChat.getSaveMessageLimit();

if (limit !== null && savedCount >= limit) {
  // Disable the save control instead of letting the user hit the error
}

JavaScript

CometChat.getSaveMessageLimit().then((limit) => {
  if (limit !== null && savedCount >= limit) {
    // Disable the save control instead of letting the user hit the error
  }
});

It resolves to null when the app settings carry no value — show generic copy in that case rather than guessing a number.

​

Feature Availability

TypeScript

let enabled: boolean = await CometChat.isSaveMessageEnabled();

if (enabled) {
  // Show the Save option
}

JavaScript

CometChat.isSaveMessageEnabled().then((enabled) => {
  if (enabled) {
    // Show the Save option
  }
});

This resolves false rather than rejecting when the flag is missing or settings are unavailable.

​

Offline Behaviour

With offline support enabled, passing a MessageFetchListener to fetchPrevious() or fetchNext() on a setSavedOnly(true) request calls onCachedMessages first (even when the page is empty) and then onServerMessages with the live list. Offline, the read ends with onError (FAILED_TO_FETCH) after the cached page, and the Promise rejects. onCachedMessages holds the user’s cached saved messages across all conversations. The saved list is answered from its own store, so other MessagesRequestBuilder filters are ignored in the cached page.

Builder method	Offline
setSavedOnly	Cached

---

​

Next Steps

Pin A Message

Highlight a message for everyone in a conversation

Pin A Conversation

Pin a conversation to the top of the list

Retrieve Conversations

Fetch and order the conversation list

Additional Message Filtering

Filter messages by saved, pinned, type, tags and more