--- title: "How to Build a Shared Customer Inbox Across Slack, Gmail, and Microsoft Team" img: https://s3.us-east-2.amazonaws.com/unified-article-images/how_to_build_a_shared_customer_inbox_across_slack_gmail_and_microsoft_team-icon.png date: 2026-03-23T23:54:00.000Z tag: Product description: "A shared customer inbox is a feature inside a SaaS product that aggregates conversations from messaging and email platforms into a single interface, allowing..." url: "https://unified.to/blog/how_to_build_a_shared_customer_inbox_across_slack_gmail_and_microsoft_team" --- # How to Build a Shared Customer Inbox Across Slack, Gmail, and Microsoft Team ------ _March 23, 2026_ A shared customer inbox is a feature inside a SaaS product that aggregates conversations from messaging and email platforms into a single interface, allowing teams to read, reply, and manage customer communication in one place. To build this, your product needs to retrieve messages from platforms like Slack, Gmail, and Microsoft Teams, group them into threads, and allow users to respond without switching tools. The challenge is that each platform exposes different APIs, message formats, and threading models. Unified provides a consistent [Messaging API](/messaging) that lets your product retrieve and send messages across these platforms using a single interface. ## Why SaaS Products Build Shared Inbox Features Many B2B SaaS products provide shared inbox functionality for their customers. Examples include: - Customer support platforms - Sales communication tools - Customer success platforms - Helpdesk products - AI support assistants These products allow teams to manage communication across channels in one place. Typical use cases include: - **Support inboxes** for handling customer requests - **Sales inboxes** for managing outbound and inbound communication - **Customer success inboxes** for account management - **AI-assisted inboxes** for automated replies and summaries ## Common Shared Inbox Use Cases Shared inbox features typically support several workflows. **Unified conversation view** Display messages from Slack, Gmail, and Teams in a single interface. **Threaded conversations** Group related messages into conversation threads. **Multi-channel replies** Allow users to respond to messages across platforms. **Team collaboration** Let multiple users participate in conversations. **Automated responses** Use AI to suggest or generate replies. ## Unified Messaging Category The Messaging API normalizes communication across multiple platforms. | Category | Description | Key Objects | | --------- | -------------------------------------------------------------------------- | ---------------- | | Messaging | Email and chat conversations across platforms like Slack, Gmail, and Teams | message, channel | This allows your product to retrieve and send messages across providers using the same API structure. ## Unified Message Object and Key Fields The **message** object represents a single communication event. Important fields include: | Field | Purpose | | ------------------------------- | ------------------------------------------ | | id | Unique identifier for the message | | message | Plain-text message body | | message_html / message_markdown | Formatted message content | | subject | Email subject | | author_member | Sender of the message | | destination_members | Recipients (To) | | mentioned_members | CC recipients | | hidden_members | BCC recipients | | created_at | Timestamp | | channels | Channel context | | attachments | Files or links | | parent_id | ID of the parent message | | message_thread_identifier | Thread identifier | | web_url | Link to the message in the source platform | These fields allow your product to display conversations consistently across platforms. ## Connecting Customer Messaging Platforms Customers connect their messaging platforms using Unified Connect. Typical flow: 1. Your application launches the authorization flow. 2. The user selects integrations such as Slack, Gmail, or Microsoft Teams. 3. The user authorizes access. 4. Unified returns a **connection_id**. Your application stores: ```plain text user_id → connection_id ``` All API requests reference this identifier. ## Retrieving Messages and Threads Messages are retrieved using: ```plain text GET /messaging/{connection_id}/message GET /messaging/{connection_id}/channel ``` ### Thread model Unified does not provide a separate thread object. Threads are reconstructed using message metadata. **Parent-based threading** - Each message includes a `parent_id` - Messages without a `parent_id` are root messages - Replies reference their parent message **Thread grouping** You can group messages by: - root message (no parent_id) - or `message_thread_identifier` (if available) ### Fetching full thread history Two approaches: **Filter by parent** ```plain text GET /messaging/{connection_id}/message?parent_id={message_id} ``` Returns direct replies. **Expand full thread** Use `expand=true` when listing messages to return all nested replies in a single request. This allows your product to reconstruct complete conversations. ## Sending and Replying to Messages Unified uses a single endpoint to send new messages and replies. ```plain text POST /messaging/{connection_id}/message ``` ### Sending a new message Provide: - message content (`message`) - recipients (`channels` or email fields) ### Replying to a thread Set: ```plain text parent_id = existing_message_id ``` This ensures the message appears in the correct thread. ### Writable fields | Field | Purpose | | ------------------------------- | ----------------- | | message | Message body | | message_html / message_markdown | Formatted content | | channels | Target channel | | destination_members | Email recipients | | mentioned_members | CC recipients | | hidden_members | BCC recipients | | author_member | Sender | | subject | Email subject | | attachments | Files or links | ### Updating messages ```plain text PUT /messaging/{connection_id}/message/{id} ``` Used to edit messages (supported in platforms like Slack). ## Building a Shared Inbox Interface A shared inbox typically combines messages into a single UI. Example structure: | Source | Activity | | ------ | --------------------------- | | Slack | Customer message in channel | | Gmail | Email thread | | Teams | Internal discussion | | Slack | Reply to conversation | Applications typically: 1. Retrieve messages across platforms 2. Group them into threads 3. Sort by `created_at` 4. Display participants using `author_member` and recipient fields 5. Allow replies using the messaging API Because Unified normalizes message objects, this logic works across all supported providers. ## Keeping Inbox Data Updated Unified provides webhook events for messaging updates. Common events include: - `message.created` - `message.updated` - `message.deleted` Additional interaction events include: - reactions - mentions - button clicks These events allow your inbox to: - update in real time - show unread messages - trigger notifications - power AI workflows ## Supported Platforms Unified supports multiple messaging integrations. Examples include: - Slack - Gmail - Microsoft Teams - Outlook - Intercom - Zendesk This allows your product to support communication across multiple channels. ## Why This Matters Building a shared inbox requires integrating multiple messaging platforms and handling different APIs, threading models, and message formats. Unified simplifies this by providing: - normalized message objects across platforms - a single endpoint for sending and replying to messages - consistent thread reconstruction using `parent_id` - real-time updates via [webhooks](/blog/replacing_polling_with_unified_webhooks_and_virtual_streams) This allows product teams to focus on building inbox features instead of managing integration complexity. Start building shared inbox features across Slack, Gmail, Microsoft Teams, and other messaging platforms today. **→** [**Start your 30-day free trial**](https://app.unified.to/login) **→** [**Book a demo**](https://calendly.com/d/cph9-g8n-jzg/connect-with-unified)