Skip to main content

Mark As Read

Marks a WhatsApp message as read via the WhatsApp Business Cloud API. This updates the message status and displays read receipts to the sender.

Common Properties​

  • Name - The custom name of the node.
  • Color - The custom color of the node.
  • Delay Before (sec) - Waits in seconds before executing the node.
  • Delay After (sec) - Waits in seconds after executing node.
  • Continue On Error - Automation will continue regardless of any error. The default value is false.
info

If the ContinueOnError property is true, no error is caught when the project is executed, even if a Catch node is used.

Inputs​

  • Phone Number ID - WhatsApp Business Phone Number ID from Meta Developer Portal.
  • Message ID - The WhatsApp message ID to mark as read (format: wamid.xxx...).

Options​

  • API Version - Meta Graph API version. Default is 21.0.
  • Access Token - WhatsApp Cloud API Access Token credential (required).

Output​

  • Response - The complete API response object containing the operation status.

How It Works​

The Mark As Read node updates a message's read status. When executed, the node:

  1. Validates all required inputs
  2. Retrieves the access token from the credential
  3. Constructs the read status payload with message ID
  4. Sends a POST request to the WhatsApp API
  5. Returns the API response confirming the status update

Requirements​

  • A WhatsApp Business Account in Meta Developer Portal
  • Access Token with appropriate permissions
  • Valid message ID from a received message
  • The message must have been sent to your business number

Error Handling​

The node will return specific errors in the following cases:

  • Empty or invalid Phone Number ID
  • Empty or invalid Message ID
  • Message ID not found
  • Message ID format invalid
  • Invalid access token
  • Network connectivity issues

Getting Message IDs​

Message IDs are obtained from the Receive Events node when messages are received:

From Receive Events Output:

{
  "messageId": "wamid.HBgNMTIzNDU2Nzg5MAAVAQAS...",
  "from": "14155551234",
  "messageBody": "Hello",
  ...
}

Example: Basic Usage​

Inputs:

  • Phone Number ID: 123456789012345
  • Message ID: wamid.HBgNMTIzNDU2Nzg5MAAVAQAS...

Result: The message is marked as read, and the sender sees blue checkmarks.

Example: Auto-Reply Flow​

Flow:

  1. Receive Events node captures incoming message
  2. Get Message ID from output
  3. Send Text Message node sends auto-reply
  4. Mark As Read node marks original message as read
// From Receive Events
const messageId = event.messageId;
const from = event.from;

// Send reply
await sendTextMessage({
  toPhoneNumber: from,
  messageText: "Thank you for your message. We'll get back to you soon."
});

// Mark as read
await markAsRead({
  messageId: messageId
});

Example: Conditional Read Receipts​

Flow:

  1. Receive Events captures message
  2. Check message type or content
  3. Only mark as read if certain conditions are met
if (messageType === "text" && messageBody.includes("urgent")) {
  // Mark urgent messages as read immediately
  await markAsRead({messageId});
}

Usage Notes​

  • Message IDs have the format wamid.xxxxx...
  • Marking a message as read displays blue checkmarks to the sender
  • You can only mark messages sent to your business number
  • Message IDs are unique and valid indefinitely
  • Read receipts respect user privacy settings
  • Multiple calls with the same message ID are safe (idempotent)

Tips for RPA Developers​

  • Store message IDs for later processing
  • Mark messages as read after successfully processing them
  • Use read receipts to acknowledge message receipt
  • Implement read status tracking in your database
  • Consider user expectations (mark as read after actual processing)
  • Don't mark as read immediately if message requires manual review
  • Log read status operations for audit
  • Handle errors gracefully (message may already be marked)

Common Use Cases​

Automated Response System:

1. Receive message
2. Send automated response
3. Mark original message as read
4. Log interaction

Message Queue Processing:

1. Receive message and store in queue
2. Process message from queue
3. Send response
4. Mark message as read
5. Remove from queue

Human Handoff:

1. Receive message
2. Analyze content
3. If automation can handle:
   - Send response
   - Mark as read
4. If requires human:
   - Don't mark as read (signals unread to agent)
   - Route to agent dashboard

Priority Handling:

1. Receive message
2. Check priority/urgency
3. High priority:
   - Process immediately
   - Mark as read
4. Low priority:
   - Add to queue
   - Mark as read later after processing

Read Receipt Behavior​

What happens when you mark a message as read:

  • Sender sees double blue checkmarks (if they have read receipts enabled)
  • Message status changes to "read" in WhatsApp
  • Timestamp of read status is recorded
  • No notification sent to sender (silent update)

What doesn't happen:

  • No message is sent to the user
  • No notification sound or vibration
  • The user's chat doesn't move to top of list

Best Practices​

  • Mark messages as read after processing them
  • Don't mark as read immediately for complex requests
  • Use read receipts as acknowledgment of receipt
  • Respect user privacy (some users disable read receipts)
  • Implement retry logic for network failures
  • Log all read status operations
  • Consider business hours before marking as read
  • Use in combination with auto-replies
  • Don't over-use (mark only when appropriate)
  • Test with real WhatsApp accounts

Common Errors and Solutions​

Error: Invalid Message ID

  • Verify message ID format (should start with wamid.)
  • Ensure you're using the full message ID
  • Check for truncation or encoding issues

Error: Message not found

  • Message ID may be incorrect
  • Message may not be sent to your business number
  • Verify the message exists in your account

Error: Already marked as read

  • This is not really an error (operation is idempotent)
  • You can safely ignore this
  • Message was already marked previously

Integration Patterns​

With CRM System:

// Receive message
const message = await receiveEvent();

// Store in CRM
await crm.createTicket({
  from: message.from,
  content: message.messageBody,
  messageId: message.messageId
});

// Mark as read
await markAsRead({
  messageId: message.messageId
});

With Analytics:

// Mark as read
await markAsRead({messageId});

// Track in analytics
analytics.track('message_read', {
  messageId: messageId,
  from: from,
  timestamp: new Date(),
  processingTime: endTime - startTime
});

Performance Considerations​

  • Marking as read is a lightweight operation
  • Safe to call multiple times (idempotent)
  • No rate limits specific to read receipts
  • Can be called asynchronously
  • Consider batching in high-volume scenarios

Privacy and Compliance​

  • Read receipts are visible to message senders
  • Respect user privacy settings
  • Some users may have read receipts disabled
  • Follow data protection regulations
  • Log read operations for audit trails
  • Consider opt-out mechanisms for automated read receipts