Research from McKinsey Global Institute found that knowledge workers spend roughly 20% of their working week searching for information or tracking down colleagues for answers, and a growing share of that communication happens inside meeting chat windows. Developers building meeting bots and AI assistants are increasingly looking to intercept, process, and respond to in-meeting chat automatically.
The challenge is that in-meeting chat in Zoom is not accessible through the REST API. Unlike cloud recordings or participant lists, chat messages during an active meeting are only available through the Zoom Meeting SDK’s chat controller, requiring a live SDK integration rather than a simple HTTP request. This catches many developers off guard when they first attempt to build chat automation.
The Zoom Meeting SDK chat system allows applications to send and receive in-meeting messages as a participating bot. Developers register a chat event listener and use a chat controller to deliver messages to all attendees or specific participants, enabling use cases ranging from command-driven bots to real-time meeting assistants.
In this article, we’ll explore how to send and receive chat messages using the Zoom Meeting SDK, covering core components, event handling, and practical patterns for building interactive meeting chat bots. Let’s get started!
Understanding In-Meeting Chat in Zoom
Zoom meetings support real-time chat communication between participants. Users can send messages to everyone in the meeting or privately to a specific participant depending on the host’s settings.
For developers, the Zoom Meeting SDK exposes chat functionality through a chat controller that allows applications to interact with the meeting chat system. Instead of using the REST API, in-meeting chat messaging must be handled directly through the SDK.
Typical use cases include:
- Meeting bots that respond to commands
- Automated assistants that send reminders
- Collaboration tools that integrate meeting chat data
- AI systems that analyze meeting conversations
With the SDK, your application becomes a participant in the meeting and can exchange chat messages like a normal user.
Key Components of Zoom Meeting SDK Chat
To implement messaging functionality, you need to understand a few core SDK components.
Chat Controller
The chat controller manages sending and receiving messages in a meeting session. Developers typically retrieve it after joining the meeting through the meeting service.
Example concept:
IMeetingChatController* chatController =
meetingService->GetMeetingChatController();This controller allows your application to:
- Send chat messages
- Receive message notifications
- monitor chat status
Chat Message Object
The SDK represents messages using chat message objects that contain information such as:
- message content
- sender user
- receiver user
- timestamp
- message ID
These objects help applications identify who sent the message and whether it was public or private.
Sending Chat Messages with the Zoom Meeting SDK
Sending messages through the SDK involves constructing a chat message and delivering it through the chat controller.
Most SDK implementations require a message builder or message object that contains the message content and recipient.
For example, in Android implementations developers create a message using a ChatMessageBuilder, set the message content, and define the receiver before sending it.
Conceptual workflow:
- Create a chat message object
- Set message text
- Define recipient (everyone or specific user)
- Send message through the chat controller
Example concept:
ChatMessageBuilder message = new ChatMessageBuilder();
message.setContent("Hello everyone!");
message.setReceiver(0); // send to allThe receiver ID determines who receives the message. If the receiver value represents everyone, the message becomes a public meeting message.
Sending Private Messages
Zoom meetings also support direct messaging between participants.
To send a private chat message:
- Retrieve the user ID of the target participant
- Assign that ID as the receiver
- Send the message through the SDK
Private messages appear only in the conversation between those two participants. Meeting hosts cannot view private chats unless they are part of that conversation.
This functionality allows developers to create features like:
- private bot responses
- moderation tools
- AI assistants that respond to individual participants
Receiving Chat Messages with the SDK
Sending messages is only one part of the system. Applications must also listen for incoming messages from meeting participants.
Zoom provides event callbacks for chat notifications.
To receive messages:
- Register a chat event listener
- Implement the message notification callback
- Process incoming message content
Developers typically implement an interface that listens for events such as onChatMsgNotification.
When someone sends a message during the meeting, the SDK triggers this callback so your application can read the message data.
Example workflow:
- Participant sends chat message
- SDK triggers message event
- Bot receives message
- Application processes message content
This mechanism enables automated bots and assistants to respond dynamically to chat messages.
Thread and Event Handling Best Practices
One common challenge when implementing Zoom chat messaging involves thread management.
The Meeting SDK requires chat operations to run on the main thread or UI thread. Attempting to send messages from background threads can cause failures or unexpected behavior.
To avoid these issues:
- Handle message sending on the main thread
- Forward background events to the main event loop
- Use proper dispatch or message queues
This ensures reliable communication between the SDK and your application.
Example Workflow for a Chat Bot
A typical Zoom meeting bot that interacts with chat messages might follow this process:
Step 1: Join Meeting
The application joins the Zoom meeting using the Meeting SDK.
Step 2: Initialize Chat Controller
After joining, the app retrieves the chat controller to manage messaging.
Step 3: Register Chat Listener
The application registers an event listener to receive incoming messages.
Step 4: Process Incoming Messages
When a participant sends a message, the event callback captures it.
Step 5: Send Response
The bot generates a response and sends it through the chat controller.
This workflow allows developers to build interactive meeting bots and automation systems.
Common Use Cases for Zoom SDK Chat Messaging
Developers use Zoom chat messaging in a variety of advanced applications.
AI Meeting Assistants
Bots that answer questions during meetings.
Command-Based Bots
Participants send commands such as:
/help
/summary
/recordThe bot processes these commands and responds automatically.
Customer Support Meetings
Support agents can automate instructions or share links via chat.
Meeting Moderation
Bots can monitor chat messages and flag inappropriate content.
Troubleshooting Chat Messaging Issues
Developers sometimes encounter problems when implementing SDK chat functionality.
Messages Not Appearing
If messages are not visible in the meeting chat, verify:
- correct receiver ID
- proper message construction
- host chat permissions
Chat Event Not Triggered
If message callbacks do not trigger:
- confirm event listener registration
- ensure correct SDK interface implementation
Background Thread Errors
If chat sending fails, move message operations to the main thread to comply with SDK requirements.
Best Practices for Zoom SDK Chat Integration
To build a reliable messaging system:
Validate Chat Permissions
Meeting hosts can restrict chat functionality. Always check meeting settings.
Handle Both Public and Private Messages
Bots should support both message types for flexible interactions.
Log Incoming Messages
Logging messages helps debugging and improves bot behavior analysis.
Design Clear Bot Responses
Bots should provide concise and useful responses to participants.
Conclusion
The Zoom Meeting SDK allows developers to build powerful meeting integrations by enabling programmatic access to chat messaging.
By using the SDK’s chat controller, registering message event listeners, and sending messages through the correct thread, applications can interact seamlessly with meeting participants.
Whether you are building a Zoom meeting bot, AI assistant, or automation tool, the ability to send and receive chat messages unlocks a wide range of possibilities.
With proper implementation and event handling, developers can transform simple meeting chats into intelligent, interactive communication systems.
How to send chat messages via Zoom Meeting SDK?
Retrieve the chat controller using meetingService-u0026gt;GetMeetingChatController() after joining the meeting. Create a message object using ChatMessageBuilder, set the content and receiver (0 for all participants, or a specific user ID for private messages), then send it through the controller. Chat operations must run on the main thread.
Can a bot read Zoom chat during a meeting?
Yes. Register an event listener implementing the onChatMsgNotification callback. When any participant sends a message, the SDK triggers this callback with a message object containing the content, sender, receiver, and timestamp. Your bot can then parse and respond to messages programmatically.
What SDK methods handle Zoom chat?
Key methods include GetMeetingChatController() to retrieve the controller, SendChatMsgTo() to send messages, and the onChatMsgNotification callback to receive incoming messages. Always register your chat event listener before the meeting starts to avoid missing early messages.
How to automate Zoom in-meeting chat?
Join the meeting as an SDK participant, initialize the chat controller, and register a message event listener. Parse incoming messages for keywords or commands, generate responses in your application logic, and send replies via the chat controller. For simpler automation without SDK overhead, managed meeting bot APIs handle the same functionality through a REST interface.
