Definition

What Are Read Receipts? How They Work in iMessage, WhatsApp and Your App

Sent, delivered, read: three small states that change how people chat. Here is what each one means, how to switch them off, and how apps build them without flooding their servers.

Delivery receipt vs read receipt

Delivery receipt

Read receipt

Question it answers

Did the message reach their device?

Did they actually see it?

What triggers it

The recipient's device receives the message

The message is on screen in an open chat

Typical UI

Two gray checks or "Delivered"

Two blue checks or "Read"

Needs the app open

No; a background sync or push can trigger it

Yes

Users can turn it off

Rarely

Usually, in privacy settings

In group chats

Per member; often shown once everyone has it

Per member; often a "Read by" list

What are read receipts?

Read receipts answer one question for the sender: has the other person seen my message? The answer shows up as a small status next to the message.

If you're here about your phone, the short version:

  • iMessage: you see "Delivered" and then "Read" under your message. Read receipts work for iMessage and RCS chats, not SMS or group texts. Turn them off in Settings > Apps > Messages > Send Read Receipts, or for one person from the contact icon at the top of the conversation.

  • WhatsApp: one gray check means sent, two gray checks mean delivered, two blue checks mean read. If you turn read receipts off, you also stop seeing other people's, and the setting doesn't apply to group chats.

The rest of this page covers how read receipts work inside an app, and what it takes to build them.

How read receipts work

1. Sent

The sender's app uploads the message. The server stores it, gives it an ID and confirms. The sender sees one check. Until then, most apps show a clock or spinner.

2. Delivered

The recipient's device gets the message, over an open WebSocket or after a push notification wakes the app, and sends a delivery receipt back: message ID, recipient and timestamp. The server relays it to the sender, whose app switches to two checks.

3. Read

When the recipient opens the conversation and the message is actually on screen, their app sends a read receipt. Most apps send one receipt for the newest visible message and treat everything before it in that conversation as read. Opening a busy chat sends one event instead of 40.

Receipts are small real-time events on the same connection as messages. The server also stores them, so a sender who was offline sees the right status when they reconnect.

Group receipts and privacy settings

Groups multiply the work. One message to a 50-person group can produce 100 receipt events: 50 delivered, 50 read. Apps handle this in a few ways:

  • Aggregate: show two checks or blue checks only once every member has the message. WhatsApp does this in groups.

  • Show detail on request: a "Read by" or message info screen lists who read it and when, fetched when the sender opens it.

  • Cap it: switch receipts off above a group size, because event volume grows with every member and every message.

Privacy controls follow a few common patterns:

  • Global toggle: stop sending read receipts. Delivery receipts usually keep flowing.

  • Per-conversation override: iMessage lets you change the setting for one contact.

  • Reciprocity: WhatsApp hides other people's receipts from you if you hide yours.

Enforce the setting where receipts are sent. If the recipient's app still emits read events and the sender's UI just hides them, anyone with a modified client can see them.

Rule of thumb: send one read receipt for the newest message on screen, not one per message. It cuts receipt traffic in busy chats and gives the sender the same answer.

Example: send a read receipt only when the message is seen

This browser snippet sends one read receipt for the newest message that is at least 60% visible while the tab is in front.

const pending = new Set();
let lastSentId = 0;

const observer = new IntersectionObserver((entries) => {
  for (const e of entries) {
    if (e.isIntersecting) pending.add(Number(e.target.dataset.messageId));
  }
  flush();
}, { threshold: 0.6 });

document.querySelectorAll('[data-message-id]').forEach((el) => observer.observe(el));
document.addEventListener('visibilitychange', flush);

function flush() {
  if (document.visibilityState !== 'visible' || pending.size === 0) return;
  const newest = Math.max(...pending);
  pending.clear();
  if (newest <= lastSentId) return;   // already covered by an earlier receipt
  lastSentId = newest;
  sendReadReceipt(newest);            // marks everything up to here as read
}

It assumes message IDs increase within a conversation. sendReadReceipt is whatever your chat SDK or socket layer provides.

Where read receipts help

  • Marketplaces and dating apps: a buyer knows the seller saw the offer, so they wait instead of sending it three more times.

  • Customer support chat: agents see whether the customer read the answer before closing the ticket.

  • Healthcare and services: confirm a patient opened appointment instructions, and fall back to SMS if they haven't after an hour.

  • Notifications: skip the push or email reminder for a message the user already read on another device.

Limits and pitfalls

  • Read means seen, not understood. A receipt only says the message was on screen.

  • Multiple devices. Reading on a laptop should clear the unread badge on the phone. Store read state per user and sync it, not per device.

  • Notification previews. Many apps don't send a read receipt when someone reads a message from a notification. Pick a rule and keep it consistent.

  • Out-of-order events. After a reconnect, "read" can arrive before "delivered". Treat read as implying delivered and never move a status backwards.

  • Large groups get expensive. Receipt traffic scales with members times messages.

Read receipts in CometChat

If you're adding chat to your own app, you don't have to design the receipt events, storage and group logic yourself.

Delivered and read states for 1:1 and group chats

The CometChat SDKs mark a message, or a whole conversation, as delivered or read with markAsDelivered(), markAsRead(), markConversationAsDelivered() and markConversationAsRead(). Senders get updates in real time through onMessagesDelivered and onMessagesRead, and for groups through onMessagesDeliveredToAll and onMessagesReadByAll. getMessageReceipts() returns per-member receipts for a message, and markAsUnread() supports "mark as unread". The group-wide events, group delivered and read timestamps, and mark as unread need the Enhanced Messaging Status feature, and group receipts are sent for groups with up to 300 online members. In the React UI Kit, receipts appear in every message bubble and can be hidden with hideReceipts.

Read the receipts docs · Start building free

Frequently asked questions

How do you know if someone read your message?

If the app supports read receipts and both of you have them on, the status under your message changes. iMessage shows "Read", WhatsApp shows two blue checks.

Can you turn off read receipts?

Usually, yes. On iPhone go to Settings > Apps > Messages and switch off Send Read Receipts, or change it for one contact inside the conversation. On WhatsApp, switch off read receipts in privacy settings; you then stop seeing other people's too.

Why does my message say delivered but not read?

The message reached their phone, but they haven't opened the chat, read it from a notification, or turned read receipts off.

Do read receipts work in group chats?

It depends on the app. WhatsApp shows blue checks in a group once every member has read the message. iMessage doesn't support read receipts in group texts.

What is the difference between delivered and read?

Delivered means the message reached the recipient's device. Read means they opened the conversation and the message was on screen.

Related terms