Plain MCP server for AI agents

Assign a thread to a user or machine user.

Create a new broadcast: a message authored once and posted to many Slack channels at once. Creating one never sends it — a new broadcast is a DRAFT, and scheduling the real send is done by a human in the Plain app. Required input fields: `name`, `content`, `contentFormat`, `type`. - `name` identifies the broadcast internally and is never shown to recipients. It is what `searchBroadcasts` matches on. - `notificationTitle` is what recipients see in the notification the broadcast arrives as. It does leave Plain. Optional here, but the broadcast cannot be sent or tested until it is set. - `type` must be `SLACK`. It is fixed at creation: content is written against a channel's rendering rules, so a broadcast cannot be moved to another channel later. - `contentFormat` and `content` go together. From MCP, send `SLACK_BLOCK_KIT` and a JSON array of Slack blocks, as `chat.postMessage` would take. A one-paragraph body looks like this, passed as a string: "[{\"type\":\"section\",\"text\":{\"type\":\"mrkdwn\",\"text\":\"Hello\"}}]" Buttons need a `url` — interactive elements do nothing in a broadcast. Images must be publicly reachable. This format cannot be edited in the Plain app. `TIPTAP` is still accepted (a serialised Tiptap document) and is what the app composer writes; do not use it unless you are copying content already stored that way. - `isLinkUnfurlingEnabled` controls whether Slack expands links and media. Defaults to true, which is Slack's own behaviour. - `appendUnsubscribeLink` controls whether Plain appends an unsubscribe footer when this broadcast is delivered. Omit to inherit the workspace default from `getBroadcastUnsubscribeLinkSetting`; pass true or false to override that default for this broadcast only. It controls footer emission, not whether unsubscribes are honoured. - `senderType` is who the broadcast is sent as: `PLAIN_WORKSPACE` posts under the workspace's own name and logo and takes no `senderUserId`; `PLAIN_USER` posts as a Plain user and requires `senderUserId`. Get user IDs from `getMyUser` or `getUserByEmail`. Leave `senderEmailAddress` unset: it belongs to a future email channel, not to a Slack broadcast. - `sendTarget` is who the broadcast reaches, resolved to concrete channels at send time. `scope: ALL_RECIPIENTS` means every connected, enabled customer channel and rejects `filters`; `scope: MATCHING` requires `filters`. Omit `scope` to target only the channels named in `recipients`. Inside `filters`, dimensions AND together and values within a dimension OR, and it must constrain something — reaching everyone is `ALL_RECIPIENTS`, not an empty filter. `audienceIds` reference saved audiences (`getBroadcastAudiences`), which must be of the same type as the broadcast. Preview the live resolved set with `getBroadcastSendTargetRecipients`. Both the sender and the target can be left unset here and filled in later with `updateBroadcast`. Use `sendTestBroadcast` to post a test copy to channels you name before a human schedules the real send.

Create a new label type that can be applied to threads.

Create a new task in Plain. Only `title` is required. Optional fields: - `description`: longer context or instructions for the task. - `status`: TODO (default), IN_PROGRESS, DONE, or CANCELLED. - `priority`: 0 (urgent), 1 (high), 2 (normal, default), or 3 (low). - `accountId`: the account this task relates to. - `assignedTo`: provide either `userId` or `machineUserId`, not both. To link the new task to a thread, pass the returned task `id` to `createThreadLink` as `plainTask: { plainTaskId }`.

Soft-delete a broadcast. Deleted broadcasts are excluded from `getBroadcasts` and `searchBroadcasts` but remain fetchable by ID with `getBroadcastDetails`, where `isDeleted` is true — so the record of what was sent survives. Deleting a broadcast whose send is already underway does not recall the messages it has already posted.

Remove a link between a thread and an external entity. Pass the threadLinkId of the link to delete (the id returned by createThreadLink or listed under a thread's links in getThreadDetails).

Fetch a paginated list of the workspace's broadcast audiences, newest first. An audience is a named, reusable set of broadcast recipients, resolved to concrete Slack channels at send time rather than when it was saved. Soft-deleted audiences are excluded. Pass `searchQuery` to narrow to audiences whose name contains it, matched case-insensitively and unanchored. The match happens in the database, so it finds audiences that are not on the current page. Use the `cursor` variable with the endCursor from the previous response's pageInfo to fetch the next page. The cursor is an opaque token: pass it back unchanged and do not construct, modify, or alter it. Set `first` to control page size (default 50). In `filters`, dimensions on one node AND together and values within a dimension OR: `tierIds: [a, b]` means either tier, while `tierIds: [a]` plus `slackChannelNameContains: ["eng"]` means both must hold. `slackChannels` are channels pinned by ID, so an audience holding only those is a saved channel list. `slackChannelNameContains` is re-resolved at send time, so it picks up channels created or renamed since. An audience with no filters at all means every tenant. An audience's own filters never contain `audienceIds` — an audience cannot be defined in terms of another one. Audience IDs start with `ba_`. Do not invent IDs — only use values returned by the MCP tools.

Fetch the individual recipients of one broadcast send — which channel got the message, which did not, and why. Use this to answer "who missed it" or "did this channel get it". A delivery is one recipient's copy of the broadcast within one send. Narrow with `deliveryStatuses`, e.g. ["FAILED"], ["SENT"], or ["SKIPPED_UNSUBSCRIBED"]. `SKIPPED_UNSUBSCRIBED` means the channel matched the audience at send time but was not posted because it had opted out — that is a different reason for missing the message than a filter that never matched, or a `FAILED` delivery with a `failureReason`. Read `failureReason` for why a `FAILED` delivery did not land. Combine with `searchQuery` to find one recipient: matched case-insensitively and unanchored against the recorded Slack channel name, the Slack channel id, and the email address, so a delivery is found by whichever of those identifies it. The match happens in the database, so it finds deliveries that are not on the current page. Omit `searchQuery` rather than passing an empty string. `slackChannelName` is the name recorded when the send resolved, so it still names a channel that was later renamed or disconnected; it is null for deliveries from before the name was recorded. This reads the send named by `broadcastSendId`. Get the id from `getBroadcastSends`; use `isTest` to distinguish test from real sends there. An id belonging to another broadcast matches nothing. `cursor` and `first` page that send's deliveries. Use the endCursor from the previous response's `deliveries.pageInfo`; it stays valid because every page selects the same send. The cursor is an opaque token: pass it back unchanged and do not construct, modify, or alter it. `deliveryCounts` on the send is the unfiltered summary of the whole send. `skippedUnsubscribed` is not part of `total`. `deliveries.totalCount` is how many rows match `deliveryStatuses` and `searchQuery`. A broadcast with hundreds of recipients has hundreds of deliveries, so prefer the counts plus a `deliveryStatuses: ["FAILED"]` or `["SKIPPED_UNSUBSCRIBED"]` query over paging the whole list. `edges` is empty when the broadcast has no send with that id. For the full send history use `getBroadcastSends`. For the live opted-out list independent of any send, use `getBroadcastRecipientUnsubscribes`. Broadcast IDs start with `bc_`, send IDs with `bcs_`, delivery IDs with `bcsd_`. Do not invent IDs — only use values returned by the MCP tools.

Fetch a paginated list of the workspace's broadcasts, newest first. A broadcast is a message authored once and posted to many Slack channels at once. Soft-deleted broadcasts are excluded from this list. Optionally narrow the list with `statuses`, e.g. ["DRAFT"] for broadcasts still being written or ["SENT"] for ones already delivered. A broadcast's status comes from its latest real send, so no status reflects a test send. Omit `statuses` to list every status — an empty list is rejected. Use the `cursor` variable with the endCursor from the previous response's pageInfo to fetch the next page. The cursor is an opaque token: pass it back unchanged and do not construct, modify, or alter it. Set `first` to control page size (default 50). `appendUnsubscribeLink` is the per-broadcast override for the unsubscribe footer (null inherits `getBroadcastUnsubscribeLinkSetting`). `latestSend` is the most recent non-test send and is where progress lives — read `deliveryCounts` from it rather than counting deliveries. `skippedUnsubscribed` is channels matched at resolve time but not posted because they opted out; it is not part of `total`. Use `getBroadcastSends` for a broadcast's full send history, and `getBroadcastSendDeliveries` for the recipients of one send. Broadcast IDs start with `bc_`. Broadcast URL format: https://app.plain.com/workspace/{workspaceId}/broadcasts/{broadcastId} where {workspaceId} is fetched via `getMyWorkspace` (starts with `w_`). Do not invent IDs — only use values returned by the MCP tools.

Return a paginated list of all customers in the workspace.

Fetch a Help Center article by its URL slug.

Return all Help Centers in the workspace.

Return all label types available in the workspace.

Return the profile of the currently authenticated workspace user.

Fetch a single snippet by ID, including soft-deleted snippets (where isDeleted is true). Use this when you already have a snippet ID from getSnippets or another tool.

Fetch detailed information about a specific task by its human-readable ref, as displayed in the Plain app (e.g. `T-123`). Returns the task's status, priority, account, assignee, the threads linked to it, and the entities that raised it (e.g. a knowledge gap). Use `threadLinksCursor` with the endCursor from the previous response's threadLinks pageInfo to fetch more linked threads. The cursor is an opaque token: pass it back unchanged and do not construct, modify, or alter it. Linked threads only carry a `threadId`; pass it to `getThreadDetails` for the thread's title, status, and context. Thread URL format: https://app.plain.com/workspace/{workspaceId}/thread/{threadId}/ where {workspaceId} is fetched via `getMyWorkspace` (starts with `w_`).

Return a paginated list of all tenants in the workspace.

Return threads with flexible filtering by status, priority, assignee, customer, labels, or date range.

Flag a customer as spam. This hides their threads from the inbox and excludes them from metrics. Marking a customer that is already marked as spam returns a `customer_already_marked_as_spam` error. Pass the customer `id` (starts with `c_`) as `customerId`. Use `getCustomers`, `searchCustomers`, or `getCustomerDetails` to discover it.

Merge one Plain thread into another (a MERGED_INTO native thread link). The child thread is merged into the parent thread; on success the child thread is marked as done. For a non-merging association between threads or to an external entity, use createThreadLink instead.

Remove one or more labels from a thread.

Remove an unsubscribe so a Slack channel can receive broadcasts again. Idempotent: resubscribing a channel that was never unsubscribed is a no-op and returns `unsubscribe: null` with no error. Required input fields: `type`, `slackTeamId`, `slackChannelId`. - `type` must be `SLACK`. A channel id is only unique within its Slack team, so both `slackTeamId` and `slackChannelId` are required together. - When an unsubscribe existed, the response's `unsubscribe` field is the record that was removed (for confirmation). When nothing was opted out, `unsubscribe` is null and `error` is also null. After a successful resubscribe, the channel returns to normal audience resolution: if a filter or named recipient would have included it, it will again. Confirm with `getBroadcastSendTargetRecipients` or `getBroadcastRecipientUnsubscribes` rather than assuming. Prefer confirming the channel identity with the user before calling this.

Semantic search across the workspace's knowledge: indexed documents (URLs and sitemaps added as knowledge sources) and help center articles that Plain's AI is allowed to use. This is the same knowledge Ari draws from, but not Ari's exact retrieval, so a result here does not guarantee Ari would have found it. Searches up to `pageSize` matching chunks (default 3, max 50), then returns one result per source, ordered by its most relevant chunk. Each result contains all indexed text from that source, so fewer than `pageSize` results may return and responses grow quickly; only raise `pageSize` if the first results miss. Narrow results with `types` (INDEXED_DOCUMENT, HELP_CENTER_ARTICLE) or `labelTypeIds` (unlabelled content may also be included). When working a knowledge gap, search its title and description before writing new content: no relevant result means the content is missing; a relevant result means it exists but Ari missed it or it is out of date, so improve the existing source rather than creating a duplicate. After updating an indexed document's page, pass its `knowledgeSourceId` to `reindexKnowledgeSource` so Ari picks up the change.

Search threads by text with optional filters for status, priority, assignee, customer, and labels.

Snooze a thread until a specified date and time.

Clear the spam flag from a customer, restoring their threads to the inbox and metrics. The `markedAsSpamAt` timestamp is cleared. Pass the customer `id` (starts with `c_`) as `customerId`. Use `getCustomers`, `searchCustomers`, or `getCustomerDetails` to discover it.

Update a broadcast audience's name, filters, or both. Only `broadcastAudienceId` is required; omitting a field leaves it unchanged. - `name` uses a wrapper input: pass `{ value: "..." }` to set it. - `filters` replaces the stored filters wholesale rather than merging into them, so read the current ones with `getBroadcastAudienceDetails` and send the full shape you want. They are validated against the audience's existing `type`, which cannot be changed. Editing an audience changes who every broadcast using it will reach on its next send, including broadcasts someone else wrote — check `getBroadcastDetails` on the broadcasts that reference it before widening or narrowing an audience.

Update the label or options of an existing thread field schema.

Create or update a Help Center article by slug.