MCP App Store
by KeenEthics
Plain icon

Plain MCP Server for ChatGPT

By Plain

Overview

Plain is AI support infrastructure for B2B teams. Your customers reach you in Slack, Microsoft Teams, Discord, email, and chat, and Plain brings every one of those conversations into one workspace. This plugin lets ChatGPT read and act in that workspace, so you can triage, reply, investigate, and report without leaving your conversation with ChatGPT. What you can do: - Triage threads: search and read conversations, assign them, set priority, apply labels, and snooze or close them - Reply to customers on the channel they wrote in (email, Slack, Microsoft Teams, Discord, or chat), and leave internal notes for your team - Ask Sidekick Agent to investigate a thread across your connected tools - Report on your queue: thread volume and trends over time, filtered and grouped the way you need - Look up and update customers and accounts, and add events to a customer's timeline - Find Knowledge Gaps, the questions your Customer Agent couldn't answer, and write or update help center articles to fill them - Link threads to issues in Linear and other issue trackers - Inspect and manage workflows Use cases: - Catch up on the queue: "What's urgent and unassigned right now? Group it by account and assign anything from Enterprise-tier accounts to me." - Prepare for a customer call: "I have a renewal call with Acme tomorrow. Summarize every thread they've opened in the last 90 days, what's still open, and which Linear issues are linked." - Close gaps in your help center: "Show me this month's top Knowledge Gaps and draft help center articles for the top three." A Plain workspace is required. For support, email help@plain.com.

How to connect

  1. ChatGPT: Open the Plain listing in the ChatGPT app directory and choose Connect. ChatGPT listing Plain exposes 404 tools here.

Tools

acceptSuggestedLabelTypes

ChatGPT
Accepts one or more pending suggested label types, creating a real label type for each and marking the suggestions as ACCEPTED. All ids must currently be PENDING. Fails the whole batch with error code label_type_name_already_exists if a suggestion's name matches an existing label type or another suggestion in the same batch. Requires the labelType:create and labelType:read permissions. Arguments: - input: AcceptSuggestedLabelTypesInput!

account

ChatGPT
Fetches a single account by its Plain-assigned ID. Returns null if no matching account is found. Requires the tenant:read permission. Arguments: - accountId: ID!

accountFieldSchemas

ChatGPT
Returns the list of account field schemas defined in the workspace. Use the source and isVisible filters to narrow results. Supports cursor-based pagination. Cursor pagination supports first and after; a page size of 50 limits response size. Arguments: - filters: AccountFieldSchemasFilter - first: Int - after: String - last: Int - before: String

accounts

ChatGPT
Returns a paginated list of accounts in the workspace. Use the filters argument to narrow the results and sortBy to order them (by name ascending when omitted). Requires the tenant:read permission. Cursor pagination supports first and after; a page size of 50 limits response size. Arguments: - first: Int - after: String - last: Int - before: String - filters: AccountsFilter - sortBy: AccountsSort

activeThreadCluster

ChatGPT
Returns the cluster that the given thread currently belongs to, or null if the thread has not been assigned to any cluster. Use this to show a customer-support agent which broader topic group a specific thread falls into. This API is in beta and may change without notice. Arguments: - threadId: ID!

addAdditionalAssignees

ChatGPT
Add one or more users or machine users as additional (secondary) assignees on a thread. Additional assignees are looped in but are not the primary person responsible. Requires the thread:assign and thread:read permissions. Arguments: - input: AddAdditionalAssigneesInput!

addCustomerToAccounts

ChatGPT
Adds a customer to one or more accounts. The customer can be identified by their Plain ID, external ID, or email address. If the customer is already a member of a given account the operation is a no-op for that account. Requires the customer:edit and customerTenantMembership:create permissions. Arguments: - input: AddCustomerToAccountsInput!

addCustomerToTenants

ChatGPT
Adds a customer to one or more tenants. The customer can be identified by their Plain ID, external ID, or email address. If the customer is already a member of a given tenant the operation is a no-op for that tenant. Requires the customer:edit and customerTenantMembership:create permissions. Deprecated. Arguments: - input: AddCustomerToTenantsInput!

addGeneratedReply

ChatGPT
Programmatically add a suggested reply to a thread. The reply is surfaced to teammates in Plain so they can review, edit, and send it — the customer sees nothing until a teammate explicitly sends it. The timelineEntryId must reference an inbound message on the thread, from the customer or from a machine user. A message the workspace sent, including one your own machine user sent, is not a valid target. The markdown field is capped at 5,000 characters. Requires the generatedReply:create permission. Arguments: - input: AddGeneratedReplyInput!

addLabels

ChatGPT
Add one or more labels to a thread. Labels that are already present on the thread are silently skipped. Archived label types are rejected with error code cannot_add_label_using_archived_label_type. Requires the label:create permission. Arguments: - input: AddLabelsInput!

addLabelsToUser

ChatGPT
Add one or more team labels to a Plain user (agent). Only label types with type TEAM may be applied to users. Label types already present on the user are silently skipped. Requires the label:create permission. Arguments: - input: AddLabelsToUserInput!

addMembersToTier

ChatGPT
Adds one or more tenants or companies to a tier (up to 25 per call). Because each tenant or company can belong to only one tier at a time, adding a member that already belongs to another tier will move it to this tier. Requires the tierMembership:read and tierMembership:create permissions. Arguments: - input: AddMembersToTierInput!

agentSandboxToolPolicies

ChatGPT
The Sidekick Agent tool approval policies for the workspace: every catalog tool with its effective approval mode (per-workspace override merged over the factory default). Optionally filter to a single service (e.g. "plain"). Arguments: - service: String

aiFeedback

ChatGPT
Paginated list of the feedback your team has submitted on Plain's AI features, such as a thumbs up or down on a Customer Agent reply, newest first. Use the optional filters argument to narrow results by feature, sentiment or submission time. Requires the aiFeatureFeedback:read permission. Cursor pagination supports first and after; a page size of 50 limits response size. Arguments: - filters: AiFeedbackFilter - first: Int - after: String - last: Int - before: String

aiToneRules

ChatGPT
Returns the workspace's AI tone rules, which guide how Plain's AI features phrase replies. Use the optional isEnabled filter to retrieve only active rules. Pagination is supported via standard first/after and last/before cursor arguments, though in practice all rules are returned in a single page. Requires the aiToneRule:read permission. Cursor pagination supports first and after; a page size of 50 limits response size. Arguments: - first: Int - after: String - last: Int - before: String - filters: AiToneRulesFilter

archiveLabelType

ChatGPT
Archives a label type so it can no longer be applied to threads, while preserving it on threads that already have it. To apply an archived label type again, unarchive it first. Requires the labelType:edit permission. Arguments: - input: ArchiveLabelTypeInput!

archiveServiceLevelAgreementPolicy

ChatGPT
Archive an SLA policy to retire it. Threads already on the policy keep it and their SLA trackers keep running, but it can no longer be assigned to other threads, by a user, the API or a workflow. Unarchive it to assign it again. Requires the serviceLevelAgreement:edit permission. Arguments: - input: ArchiveServiceLevelAgreementPolicyInput!

assignThread

ChatGPT
Assign a thread to a specific user or machine user, replacing any existing primary assignee. Requires the thread:assign and thread:read permissions. Arguments: - input: AssignThreadInput!

billingPlans

ChatGPT
Returns the available billing plans that can be selected for self-serve checkout. Supports standard forward and backward pagination. Cursor pagination supports first and after; a page size of 50 limits response size. Arguments: - first: Int - after: String - last: Int - before: String

broadcastRecipientUnsubscribes

ChatGPT
Returns a paginated list of Slack channels that have opted out of broadcasts, newest first. Requires the broadcast:read permission and the broadcasts feature flag. The user resubscribes a channel in the Plain app at https://app.plain.com/workspace/w_…/broadcasts/unsubscribes; replace w_… with this workspace's ID. Cursor pagination supports first and after; a page size of 50 limits response size. Arguments: - searchQuery: String — Narrows to unsubscribes whose connected channel name contains this, or whose Slack workspace name contains this, matched case-insensitively and unanchored. Channel-name matches exclude disconnected channels; a workspace-name match returns every opted-out channel in that Slack workspace, including disconnected ones. - first: Int - after: String - last: Int - before: String

broadcasts

ChatGPT
Returns a paginated list of the workspace's broadcasts, newest first. Soft-deleted broadcasts are excluded. Optionally narrow the results with filters (status). Supports standard forward and backward cursor pagination. Requires the broadcast:read permission. Cursor pagination supports first and after; a page size of 50 limits response size. Arguments: - filters: BroadcastsFilter - first: Int - after: String - last: Int - before: String

bulkJoinSlackChannels

ChatGPT
Instructs the Plain Slack bot to join public Slack channels for the given workspace Slack channel integration. By default it joins every public channel matching an auto-join rule on the integration. Set rule to join only the public channels matching one rule, identified by its channel name prefix and suffix. Arguments: - input: BulkJoinSlackChannelsInput!

bulkUpdateConnectedSlackChannels

ChatGPT
Applies many connected-slack-channel updates in a single request. Each update is applied independently; partial failures are reported per item. Arguments: - input: BulkUpdateConnectedSlackChannelsInput!

bulkUpdateSlackChannelSettings

ChatGPT
Applies many Slack per-channel setting writes in a single request. Each update writes a setting at the WORKSPACE_SLACK_CONNECTED_CHANNEL scope. The writes are attempted independently; partial failures are reported per-item. Arguments: - input: BulkUpdateSlackChannelSettingsInput!

bulkUpsertThreadFields

ChatGPT
Upserts up to 25 thread field values in a single call — useful when setting multiple fields on one or more threads at once. Each entry is independently created or updated; a validation error on the batch as a whole is returned if any entry is invalid. Requires the threadField:create and threadField:update permissions. Arguments: - input: BulkUpsertThreadFieldsInput!

bulkUpsertWorkflowSteps

ChatGPT
Atomically replace all steps in a workflow. Steps with a matching stepId are updated; steps without an ID (or with a new ID) are created; steps that existed before but are absent from the input are deleted. Optionally updates startStepId and the trigger configuration in the same call. Maximum 60 steps per workflow. Arguments: - input: BulkUpsertWorkflowStepsInput!

businessHoursOverride

ChatGPT
Fetches a single business hours override by its ID, or null if no override with that ID exists. Requires the businessHours:read permission. Arguments: - businessHoursOverrideId: ID!

businessHoursOverrides

ChatGPT
Returns a paginated list of business hours overrides across the workspace's schedules, sorted by start date. Filter by schedule, start date or end date. Requires the businessHours:read permission. Cursor pagination supports first and after; a page size of 50 limits response size. Arguments: - filters: WorkspaceBusinessHoursOverridesFilter - sortBy: BusinessHoursOverridesSort - first: Int - after: String - last: Int - before: String

businessHoursSchedule

ChatGPT
Fetches a single business hours schedule by its ID, or null if no schedule with that ID exists. Requires the businessHours:read permission. Arguments: - businessHoursScheduleId: ID!

businessHoursSchedules

ChatGPT
Returns a paginated list of the workspace's business hours schedules, sorted by name. Requires the businessHours:read permission. Cursor pagination supports first and after; a page size of 50 limits response size. Arguments: - first: Int - after: String - last: Int - before: String

cancelPendingWorkflowExecutions

ChatGPT
Cancel every QUEUED and WAITING execution of a workflow. Running executions are left to finish. Arguments: - input: CancelPendingWorkflowExecutionsInput!

cancelWorkflowExecution

ChatGPT
Cancel a QUEUED or WAITING workflow execution. It stops where it is: a waiting execution does not take its wait step's cancelled branch. Fails with workflow_execution_not_cancellable for any other status. Arguments: - input: CancelWorkflowExecutionInput!

changeThreadCustomer

ChatGPT
Reassign a thread to a different customer. The original customer retains all their other threads. Requires the thread:edit permission. Arguments: - input: ChangeThreadCustomerInput!

changeThreadDiscussionStatus

ChatGPT
Moves a discussion between OPEN and RESOLVED. Callable by a person, by the custom agent a discussion is bound to, or by the machine user that started a Sidekick Agent discussion. Arguments: - input: ChangeThreadDiscussionStatusInput!

changeThreadPriority

ChatGPT
Set the priority of a thread. Priority is an integer from 0 (urgent) to 3 (low). Requires the thread:edit permission. Arguments: - input: ChangeThreadPriorityInput!

chatApp

ChatGPT
Fetch a single chat app by its ID. Returns null if no chat app with that ID exists in the workspace. Requires the chatApp:read permission. Deleting a chat app is done by the user in the Plain app. The Plain app page is https://app.plain.com/workspace/w_…/settings/chat/<chatAppId>. Arguments: - chatAppId: ID!

chatAppSecret

ChatGPT
Check whether a signing secret exists for a chat app. Returns metadata about the secret (creation time, actor) but never the secret value itself — the raw secret is only returned once, at creation time. Returns null if no secret has been created for the given chat app. Requires the chatAppSecret:read permission. Arguments: - chatAppId: ID!

chatApps

ChatGPT
List all chat apps in the workspace. Supports cursor-based pagination. Requires the chatApp:read permission. Deleting a chat app is done by the user in the Plain app. The Plain app page is https://app.plain.com/workspace/w_…/settings/chat/<chatAppId>. Cursor pagination supports first and after; a page size of 50 limits response size. Arguments: - first: Int - after: String - last: Int - before: String

connectedAgentTemplates

ChatGPT
List the templates for connecting your own AI agent to Plain: Internal, for an agent that works with your team and cannot message customers, and Customer, for an agent that replies to customers. Each template gives the API key permissions and webhook event types to start from when setting up a connected agent's machine user, API key and webhook target. They are suggested defaults that admins can add to. Requires the permission:read and subscriptionEventTypes:read permissions.

connectedDiscordChannels

ChatGPT
Returns a paginated list of Discord channels synced from a specific guild. The list reflects the channels last synced from Discord. Not connected yet? Connecting needs the user's approval in the provider. The Plain app page is https://app.plain.com/workspace/w_…/install/discord. Cursor pagination supports first and after; a page size of 50 limits response size. Arguments: - discordGuildId: String! - first: Int - after: String - last: Int - before: String

connectedMSTeamsChannels

ChatGPT
Returns a paginated list of Microsoft Teams channels that are connected to this workspace. Supports forward and backward cursor pagination. Not connected yet? Connecting needs the user's approval in the provider. The Plain app page is https://app.plain.com/workspace/w_…/install/ms-teams. Cursor pagination supports first and after; a page size of 50 limits response size. Arguments: - first: Int - after: String - last: Int - before: String

connectedSlackChannel

ChatGPT
Returns a single connected Slack channel by its Plain ID, or null if not found. Arguments: - connectedSlackChannelId: ID!

connectedSlackChannelIngestionSettings

ChatGPT
Returns the ingestion settings a connected Slack channel resolves to, each with where the value comes from. A value is the channel override if one is set, otherwise the team value for the Slack integration, otherwise the Plain default. The mode is the configured value; ingestion creates threads as TIME_BASED while it is AI_BASED and Plain AI is unavailable. The settings apply to customer channels. Returns null if the channel is not found or the workspace has no Slack integration for the channel's Slack team. Arguments: - connectedSlackChannelId: ID!

connectedSlackChannels

ChatGPT
Gets all slack channels for this workspace, which match the specified filters. This list can include channels that opted out of broadcasts and does not represent a broadcast audience. Cursor pagination supports first and after; a page size of 50 limits response size. Arguments: - filters: ConnectedSlackChannelsFilter - first: Int - after: String - last: Int - before: String

createAccount

ChatGPT
Creates a new account. Fails with a validation error if an account already exists with the provided externalId. Requires the tenant:create permission. Arguments: - input: CreateAccountInput!

createAiFeedback

ChatGPT
Submit feedback on any Plain AI feature result. Pass a JSON-encoded object in the feedback field whose type discriminates the feature (AI_AGENT, THREAD_CATCHUP, THREAD_CLUSTERS, TONE_RULE, or KNOWLEDGE_GAP) and includes the relevant context fields and an optional sentiment (POSITIVE, NEGATIVE, or NEUTRAL). Arguments: - input: CreateAiFeedbackInput!

createAllTestThreads

ChatGPT
Create one test thread per scenario for the signed-in user, so they get a populated inbox in a single call. Each thread comes from that scenario's own test customer, and its opening message is written shortly after this returns. Scenarios the caller already has a test thread for are skipped, so calling this again tops the set up rather than duplicating it, and a scenario that fails does not stop the rest. Requires the thread:create permission.

createAttachmentUploadUrl

ChatGPT
Generate a presigned upload URL for an attachment. Use the returned uploadFormUrl and uploadFormData fields to POST the file as multipart/form-data directly to storage. The upload URL expires after 2 hours; the resulting attachment.id identifies the uploaded file in messages or notes. Requires the attachment:create permission. Attachments that are never referenced in a message are automatically deleted after 24 hours. Arguments: - input: CreateAttachmentUploadUrlInput!

createBroadcast

ChatGPT
Creates a new broadcast in the workspace. The content is encoded as declared by contentFormat and authored against the rendering rules of the given type. Requires the broadcast:create permission. Arguments: - input: CreateBroadcastInput!

createBroadcastAudience

ChatGPT
Creates a reusable broadcast audience. filters is validated against type, so a filter naming a dimension that type cannot resolve is rejected here rather than resolving to nobody at send time. Requires the broadcastAudience:create permission. Arguments: - input: CreateBroadcastAudienceInput!

createBusinessHoursOverride

ChatGPT
Create an override that replaces a schedule's weekly hours from startsOn to endsOn, e.g. a holiday. Can't overlap another override on the same schedule. Requires the businessHours:create permission. Arguments: - input: CreateBusinessHoursOverrideInput!

createBusinessHoursSchedule

ChatGPT
Create a new named business hours schedule, optionally with its opening slots. Overlapping and adjacent slots are merged on write. Requires the businessHours:create permission. Arguments: - input: CreateBusinessHoursScheduleInput!

createChatApp

ChatGPT
Create a new chat app, which represents a source of chat messages (e.g. a specific in-product widget or integration). Optionally supply a logo using a previously uploaded workspace file ID. The logo must be a public, image-type workspace file. Requires the chatApp:create permission and the live-chat billing entitlement. Arguments: - input: CreateChatAppInput!

createCustomerCardConfig

ChatGPT
Creates a new customer card config. New configs are placed at the bottom of the list (order 100000) by default. A maximum of 25 card configs can be created per workspace. Returns a too_many_customer_card_configs error if the limit is reached. The key must be unique within the workspace and is used in the request payload sent to your API URL. Arguments: - input: CreateCustomerCardConfigInput!

createCustomerEvent

ChatGPT
Creates a customer event that appears in the timeline of every thread belonging to the customer. Use this to surface important product activity (e.g. a failed payment, a deleted API key) so your team has full context when helping the customer. The event layout is defined using Plain UI components. Requires the customerEvent:create permission. Arguments: - input: CreateCustomerEventInput!

createDashboard

ChatGPT
Creates a dashboard. Requires dashboard:create. Arguments: - input: CreateDashboardInput!

createEmailPreviewUrl

ChatGPT
Generates a short-lived URL that can be used to preview the rendered HTML of an email. Useful for displaying email content in external tools or dashboards. Arguments: - input: CreateEmailPreviewUrlInput!

createEscalationPath

ChatGPT
Creates a new escalation path with the given name, optional description, and an ordered list of steps (up to 20). Each step routes the thread to either a specific user or the owners of a label type. Steps must not contain duplicates. Requires the escalationPath:create permission and the escalation paths feature entitlement. Arguments: - input: CreateEscalationPathInput!

createHelpCenter

ChatGPT
Create a help center with its names, description, type, subdomain, colour and logo. Requires the helpCenter:edit permission. Pass each field as its own argument, not wrapped in an input object. Custom JavaScript and sign-in can't be set here, because they run code on every public page or take a secret. The user sets them in the Plain app: the page is https://app.plain.com/workspace/w_…/help-center/<helpCenterId>.

createHelpCenterArticleGroup

ChatGPT
Create a new article group (folder) within a help center. Pass parentHelpCenterArticleGroupId to nest the group inside an existing group. Requires the helpCenter:edit permission. Arguments: - input: CreateHelpCenterArticleGroupInput!

createIndexedDocument

ChatGPT
Manually add a single URL as an indexed document within an existing knowledge source. The document is fetched and queued for indexing asynchronously. Requires Plain AI to be enabled on the workspace. Arguments: - input: CreateIndexedDocumentInput!

createIssueTrackerIssue

ChatGPT
Create a new issue in a connected issue tracker (Shortcut, Rootly, incident.io, or GitHub) and return a ThreadLinkCandidate that identifies the created issue as a possible thread link target. The fields array must include all required fields for the chosen tracker (including the required fields and their allowed values). For GitHub, the acting user must have a personal GitHub user auth integration set up; the issue is created on their behalf. Requires the threadLink:create permission. Arguments: - input: CreateIssueTrackerIssueInput!

createKnowledgeGapSignal

ChatGPT
Record a knowledge gap signal on a thread: a sign that your knowledge base did not have the answer to what a customer asked. Use it when your own AI agent hands a thread over to your team or when your team reviews threads. Plain checks whether the signal points at a real gap and groups it with similar signals. A gap that is hit twice becomes a task. The signal is tied to the latest message in the thread, so calling this again before a new message arrives returns the existing signal instead of creating a second one. Optionally pass what your agent searched for and which help center articles or indexed documents it found. Knowledge gaps and Plain AI must be enabled for the workspace. Requires the knowledgeGapSignal:create and knowledgeGapSignal:read permissions, plus read access to the thread, its timeline and any referenced documents. Without knowledgeGapSignal:read, a repeat call that would return an existing signal fails. Arguments: - input: CreateKnowledgeGapSignalInput!

createKnowledgeSource

ChatGPT
Create a new knowledge source that Plain AI will index and use when generating replies. Use type SITEMAP to crawl all URLs listed in a sitemap XML file, or type URL to index a single page. Requires Plain AI to be enabled on the workspace. Arguments: - input: CreateKnowledgeSourceInput!

createLabelType

ChatGPT
Creates a new label type in the workspace. Label types define the labels available to apply to threads and users. Requires the labelType:create permission. Arguments: - input: CreateLabelTypeInput!

createMachineUser

ChatGPT
Creates a new machine user in the workspace. Each machine user can hold multiple API keys and optionally has a public-facing name shown to customers. Only one machine user of type AI_AGENT is allowed per workspace. Requires the machineUser:create permission. Arguments: - input: CreateMachineUserInput!

createMcpFeedback

ChatGPT
Report a problem or an idea about Plain's MCP tools to the Plain team. The report can describe a tool error, a missing capability, or an improvement idea. Describe the problem in comment and name the tool in toolName if one was involved. Do not include customer data, personal information, or message content in comment. Requires the aiFeatureFeedback:create permission. Arguments: - input: CreateMcpFeedbackInput!

createMyFavoritePage

ChatGPT
Saves a page as a favorite for the currently authenticated user. If the caller has already favorited a page with the same key, the existing record is returned unchanged (idempotent). Requires the favoritePage:create permission. Arguments: - input: CreateMyFavoritePageInput!

createNote

ChatGPT
Creates an internal note visible only to your team. Notes appear in the thread timeline alongside customer messages and are useful for sharing context, reminders, or annotations. customerId, threadId and text are required: a note is always pinned to one thread. Requires the note:create permission. Arguments: - input: CreateNoteInput!

createSavedThreadsView

ChatGPT
Creates a new saved threads view in the workspace. The view stores a named filter configuration (including sort order, grouping, layout, and display options) that can be applied when querying threads. Requires the savedThreadsView:create permission; depending on workspace settings, only admins or all members may be allowed to create views. Arguments: - input: CreateSavedThreadsViewInput!

createServiceLevelAgreement

ChatGPT
Create a service level agreement (SLA) for a tier. Each SLA commits your team to a time target and can be scoped by thread priority and/or label type. Provide exactly one of firstResponseTimeMinutes (time from thread creation to first reply), nextResponseTimeMinutes (time from each customer message to the next reply), firstResolutionTimeMinutes (time from thread creation to first Done), or totalResolutionTimeMinutes (time from thread creation to Done, including after reopen). A nextResponseTimeMinutes SLA can only be created if a firstResponseTimeMinutes SLA already exists on the same tier. Requires the serviceLevelAgreement:create permission. Arguments: - input: CreateServiceLevelAgreementInput!

createServiceLevelAgreementPolicy

ChatGPT
Create an SLA policy together with its targets. A policy holds at most one target per type, and any combination of types is valid. Business hours schedules are chosen once per policy: every target that uses business hours must reference the same schedules, and a target with none is tracked 24/7. A policy only starts tracking once it is applied to a thread. Requires the serviceLevelAgreement:create permission. Arguments: - input: CreateServiceLevelAgreementPolicyInput!

createSidekickCustomSkill

ChatGPT
Create an enabled workspace custom skill. The unique URL-safe slug is derived from displayName. Arguments: - input: CreateSidekickCustomSkillInput!

createSnippet

ChatGPT
Creates a new snippet in the workspace. The name is used to search for the snippet when composing a reply. Provide markdown in addition to text to supply a rich-text version used in channels that support markdown. The optional path (alphanumeric only) places the snippet in a folder in the Plain app. Requires the snippet:create permission. Arguments: - input: CreateSnippetInput!

createTask

ChatGPT
Create a new task. Only title is required; description, status, priority, assignee, and a parent companyId or tenantId are all optional. A task may be linked to either a company or a tenant, but not both. Requires the task:create permission. Arguments: - input: CreateTaskInput!

createTenant

ChatGPT
Creates a new tenant. Fails with a validation error if a tenant already exists with the provided externalId. Requires the tenant:create permission. Deprecated. Arguments: - input: CreateTenantInput!

createTestThread

ChatGPT
Create a test thread for the signed-in user. Test threads come from a test customer rather than a real one. The scenario is picked for you and fixes the thread's title; its opening message is written shortly after this returns. They are visible in the test-thread list only to the user who created them. Pass channel: SLACK to have the conversation happen in the workspace's Slack test channel instead of chat, so the caller sees a thread arrive the way a customer's Slack message does. Requires the thread:create permission. Arguments: - input: CreateTestThreadInput

createThread

ChatGPT
Create a new thread for a customer. Commonly used when a customer submits a contact form or when you want to start a proactive support interaction from your own product. The thread is created in TODO status. You can optionally set a title, priority, assignee, labels, thread fields, tenant, and an externalId for later lookup. Requires the thread:create and thread:read permissions. Arguments: - input: CreateThreadInput!

createThreadDiscussion

ChatGPT
Start a new discussion on a Plain thread. Supports Slack (posts a new thread in a connected Slack channel), Email (sends an outbound email chain), and Cursor workspace background agent discussions. The markdownContent field is sent as the opening message; for Slack discussions you may also supply slackBlocks (JSON-encoded Block Kit array) for rich Slack formatting while markdownContent serves as the Plain UI fallback. Prefer createDiscussion for new integrations. Arguments: - input: CreateThreadDiscussionInput!

createThreadEvent

ChatGPT
Creates a thread event that appears only in the timeline of the specified thread. Use this when an activity is specific to a single conversation rather than the customer as a whole. The event layout is defined using Plain UI components. Thread events are visible only to your team and are never shown to the customer. Requires the threadEvent:create and threadEvent:read permissions. Arguments: - input: CreateThreadEventInput!

createThreadFieldSchema

ChatGPT
Creates a new thread field schema, defining a custom field that can be attached to threads. The key must be unique within the workspace and cannot be changed after creation. Requires the threadFieldSchema:create permission. Arguments: - input: CreateThreadFieldSchemaInput!

createThreadFromSlackMessage

ChatGPT
Creates a thread from a top-level message in a connected customer Slack channel, along with the replies Plain has already received for it. This is the trigger for the API_ONLY ingestion mode, and works in every other mode too. Ingestion runs asynchronously, so thread is returned only when the message had already been ingested. Requires the thread:create permission. This is not a way to import historic conversations: only replies Plain saw over the Slack events API are included, so a message from before the Plain bot joined the channel becomes a thread missing everything that was said before then. Arguments: - input: CreateThreadFromSlackMessageInput!

createTier

ChatGPT
Creates a new tier. You can optionally add tenant and company members at creation time. Requires the tier:create permission. Arguments: - input: CreateTierInput!

createWorkflow

ChatGPT
Create a new workflow. The workflow starts unpublished with no steps. The trigger field must be a valid JSON-encoded trigger configuration. Arguments: - input: CreateWorkflowInput!

createWorkflowStep

ChatGPT
Add a single step to a workflow. Arguments: - input: CreateWorkflowStepInput!

createWorkspaceFileDownloadUrl

ChatGPT
Generate a fresh download URL for a workspace file. For PRIVATE files, returns a short-lived pre-signed URL (valid for 3 minutes); for PUBLIC files, returns a permanent CDN URL with no expiry. Arguments: - input: CreateWorkspaceFileDownloadUrlInput!

createWorkspaceFileUploadUrl

ChatGPT
Begin a two-step file upload. Returns a pre-signed S3 form URL and form data fields that you POST the raw file bytes to directly from the client. The upload URL expires in 2 hours. Files must be 50 MB or smaller; certain executable file extensions (e.g. .exe, .bat) are rejected. Requires the workspaceFile:create permission. Arguments: - input: CreateWorkspaceFileUploadUrlInput!

createWorkspaceSlackIntegrationFromAuth

ChatGPT
Connects a workspace-level Slack notifications integration reusing a Slack connection the workspace already has, with no second OAuth install. Pass the ID of an existing workspace Slack channel integration (wsSlackInt_…); the notifications integration doesn't exist until this creates it. Choose the notification channel afterwards with the notification/slack/channel_id setting. Arguments: - input: CreateWorkspaceSlackIntegrationFromAuthInput!

cursorRepositories

ChatGPT
Returns the list of GitHub repositories accessible via the given Cursor integration. Results are fetched live from the Cursor API and cached for up to 5 minutes. Requires the workspaceCursorIntegration:read permission. Arguments: - integrationId: ID!

customRole

ChatGPT
Returns a single custom role by its ID, or null if not found. Requires the roles:read permission. Changing a role's permissions or which threads it can see is done by the user in the Plain app. The Plain app page is https://app.plain.com/workspace/w_…/settings/roles/<customRoleId>. Arguments: - customRoleId: ID!

customRoles

ChatGPT
Returns the workspace's custom roles. Each includes its name, the Support or Viewer base role it inherits (permissionsPreset), and thread visibility rules (scopeDefinitions) that limit which threads a member can see by account, tier, label, or channel. An empty scopeDefinitions list means every thread is visible. A custom role has the same permissions as its base role, and individual permissions can't be added or removed. Supports cursor-based pagination. Requires the roles:read permission. Changing a role's permissions or which threads it can see is done by the user in the Plain app. The Plain app page is https://app.plain.com/workspace/w_…/settings/roles/<customRoleId>. Cursor pagination supports first and after; a page size of 50 limits response size. Arguments: - first: Int - after: String - last: Int - before: String

customerByEmail

ChatGPT
Fetch a customer by their email address. Returns null if no customer with that email exists. Requires the customer:read permission. Arguments: - email: String!

customerByExternalId

ChatGPT
Get a customer by its external ID. A customer's external ID is unique within a workspace. Arguments: - externalId: ID!

customerCardConfig

ChatGPT
Returns a single customer card config by ID. Returns null if no config with the given ID exists. Deleting a card is done by the user in the Plain app. The Plain app page is https://app.plain.com/workspace/w_…/settings/customer-cards/<customerCardConfigId>. Arguments: - customerCardConfigId: ID!

customerCardConfigs

ChatGPT
Returns all customer card configs for the workspace, ordered by their order field. Deleting a card is done by the user in the Plain app. The Plain app page is https://app.plain.com/workspace/w_…/settings/customer-cards/<customerCardConfigId>.

customerCardInstances

ChatGPT
Returns the current customer card instances for a customer, triggering a fresh load for any cards that are expired or in an error state. Cards that are cached and within their TTL are returned immediately as CustomerCardInstanceLoaded. Cards that need to be fetched are returned as CustomerCardInstanceLoading; the load completes asynchronously. Pass threadId to provide thread context to your card API endpoint. A maximum of 25 card instances will be returned, due to only allowing 25 customer card configs. Arguments: - customerId: ID! - threadId: ID

customerSurvey

ChatGPT
Fetches a single customer survey by its ID. Returns null if no survey with that ID exists. Arguments: - id: ID!

customerSurveys

ChatGPT
Returns a paginated list of all customer surveys configured in the workspace, ordered by their display order. Use this to build management UIs or sync survey configurations. Cursor pagination supports first and after; a page size of 50 limits response size. Arguments: - first: Int - after: String - last: Int - before: String

customers

ChatGPT
Fetch a paginated list of all customers in the workspace. Supports filtering by group membership, company, spam status and more via filters, and ordering via sortBy. Use cursor-based pagination (first/after or last/before) to page through large result sets. Requires the customer:read permission. Cursor pagination supports first and after; a page size of 50 limits response size. Arguments: - filters: CustomersFilter - sortBy: CustomersSort - first: Int - after: String - last: Int - before: String

dashboard

ChatGPT
A single dashboard with its widgets. Null if it doesn't exist. Requires dashboard:read. Arguments: - dashboardId: ID!

dashboards

ChatGPT
Every dashboard in the workspace. Requires dashboard:read. Cursor pagination supports first and after; a page size of 50 limits response size. Arguments: - first: Int - after: String - last: Int - before: String

deleteAiToneRules

ChatGPT
Permanently deletes one or more AI tone rules by ID. If any supplied ID does not exist the entire operation fails and no rules are deleted. Requires the aiToneRule:delete permission. Arguments: - input: DeleteAiToneRulesInput!

deleteAllTestThreads

ChatGPT
Permanently delete every test thread belonging to the signed-in user.

deleteBroadcast

ChatGPT
Soft-deletes a broadcast. Deleted broadcasts are excluded from lists and searches but remain fetchable by ID with isDeleted: true. Requires the broadcast:delete permission. Arguments: - input: DeleteBroadcastInput!

deleteBroadcastAudience

ChatGPT
Soft-deletes a broadcast audience. Rejected with cannot_delete_broadcast_audience while a broadcast targeting it is scheduled or being sent, since past SCHEDULED its author can no longer edit the reference away. Requires the broadcastAudience:delete permission. Arguments: - input: DeleteBroadcastAudienceInput!

deleteBusinessHoursOverride

ChatGPT
Delete an override. The schedule's weekly hours apply to its dates again. Requires the businessHours:delete permission. Arguments: - input: DeleteBusinessHoursOverrideInput!

deleteBusinessHoursSchedule

ChatGPT
Delete a business hours schedule and the slots belonging to it. Requires the businessHours:delete permission. Arguments: - input: DeleteBusinessHoursScheduleInput!

deleteCustomerSurvey

ChatGPT
Permanently deletes a customer survey. Returns an error if the survey does not exist. Requires the customerSurvey:delete permission. Arguments: - input: DeleteCustomerSurveyInput!

deleteDashboard

ChatGPT
Deletes a dashboard and its widgets. Requires dashboard:delete. Arguments: - input: DeleteDashboardInput!

deleteEscalationPath

ChatGPT
Permanently deletes an escalation path by ID. Returns an error if the escalation path does not exist. Threads that were attached to this escalation path will lose their escalation path association. Requires the escalationPath:delete permission. Arguments: - input: DeleteEscalationPathInput!

deleteHelpCenterArticleGroup

ChatGPT
Delete an article group. Articles that belonged to the group are not deleted — they become ungrouped. To remove articles entirely, use deleteHelpCenterArticle. Requires the helpCenter:edit permission. Arguments: - input: DeleteHelpCenterArticleGroupInput!

deleteKnowledgeSource

ChatGPT
Delete a knowledge source and remove it from Plain AI's index. This is idempotent — deleting a knowledge source that does not exist returns no error. Arguments: - input: DeleteKnowledgeSourceInput!

deleteMyFavoritePage

ChatGPT
Removes a favorite page for the currently authenticated user. If the specified favorite page does not exist or belongs to a different user, the mutation succeeds silently with no error. Requires the favoritePage:delete permission. Arguments: - input: DeleteMyFavoritePageInput!

deleteSavedThreadsView

ChatGPT
Permanently deletes a saved threads view. Returns an error if the view does not exist. Depending on workspace settings, only the view's creator or workspace admins may be allowed to delete a view they did not create. Arguments: - input: DeleteSavedThreadsViewInput!

deleteServiceLevelAgreement

ChatGPT
Delete an SLA from a tier. A first-response-time SLA cannot be deleted while a next-response-time SLA still exists on the same tier — delete the next-response SLA first. Returns the deleted SLA on success. Requires the serviceLevelAgreement:delete permission. Arguments: - input: DeleteServiceLevelAgreementInput!

deleteSidekickCustomSkill

ChatGPT
Permanently delete a workspace custom skill. Returns a not-found error if the skill does not exist. Arguments: - input: DeleteSidekickCustomSkillInput!

deleteSnippet

ChatGPT
Soft-deletes a snippet. Deleted snippets are hidden from the snippet picker but remain fetchable by ID with isDeleted: true, preserving the history of replies that referenced them. Requires the snippet:delete permission. Arguments: - input: DeleteSnippetInput!

deleteTestThread

ChatGPT
Permanently delete one of the signed-in user's own test threads. Other threads are reported as not found. Arguments: - input: DeleteTestThreadInput!

deleteThreadField

ChatGPT
Removes a stored thread field value from a thread, identified by thread ID and field key. Has no effect if the field has no value. Requires the threadField:delete permission. Arguments: - input: DeleteThreadFieldInput!

deleteWorkflow

ChatGPT
Permanently delete a workflow and all its steps. Existing executions are retained for audit purposes. Arguments: - input: DeleteWorkflowInput!

deleteWorkflowStep

ChatGPT
Delete a single step from a workflow. You are responsible for updating any steps that reference this step in their transitions. Arguments: - input: DeleteWorkflowStepInput!

deletedThreads

ChatGPT
Paginated list of threads that have been deleted. Only threads deleted after the deletion audit log was enabled for your workspace are included. Useful for auditing or syncing deletions to an external system. Requires the thread:read permission. Cursor pagination supports first and after; a page size of 50 limits response size. Arguments: - filters: DeletedThreadsFilter - first: Int - after: String - last: Int - before: String

dismissGeneratedReply

ChatGPT
Dismiss a suggested reply so teammates no longer see it. Use this when a suggestion is wrong, out of date, or was already sent by hand. Dismissing an already dismissed reply has no effect. A new suggested reply can still be added for the same message. Requires the generatedReply:edit permission. Arguments: - input: DismissGeneratedReplyInput!

dismissSuggestedLabelTypes

ChatGPT
Dismisses one or more pending suggested label types without creating label types. All ids must currently be PENDING. Requires the labelType:create permission. Arguments: - input: DismissSuggestedLabelTypesInput!

duplicateBroadcast

ChatGPT
Copies an existing broadcast into a new draft. Authoring fields (content, audience, sender, notification title, and related settings) are copied. Send history, schedule, recipients, and delivery stats are not. The copy is named Copy of <original name>. Requires the broadcast:create and broadcast:read permissions. Arguments: - input: DuplicateBroadcastInput!

editQueuedAgentSessionMessage

ChatGPT
Edits the text of a user message that is waiting in a Sidekick Agent AGENT_SESSION queue. Attachments are not editable in this flow — delete and re-send to change them. Rejects with queued_agent_session_message_already_dispatched if the agent has already picked the message up. Arguments: - input: EditQueuedAgentSessionMessageInput!

emailSuppression

ChatGPT
Returns the suppression for a specific email address, or null when the address is not suppressed. Arguments: - emailAddress: String!

enabledAiToneRulesText

ChatGPT
Returns all currently enabled AI tone rules serialised as a plain-text instruction string that is suitable for injecting into AI prompts. Returns null when no rules are enabled or the feature flag is off. Requires the aiToneRule:read permission.

escalateThread

ChatGPT
Advance a thread to the next step in its escalation path. The thread must already have an escalation path attached — if not, this call returns an error. Requires the thread:edit permission. Arguments: - input: EscalateThreadInput!

escalationPath

ChatGPT
Fetches a single escalation path by its ID. Returns null if no escalation path with the given ID exists. Requires the escalationPath:read permission. Arguments: - id: ID!

escalationPaths

ChatGPT
Returns a paginated list of all escalation paths configured in the workspace. Requires the escalationPath:read permission. Cursor pagination supports first and after; a page size of 50 limits response size. Arguments: - first: Int - after: String - last: Int - before: String

forkThread

ChatGPT
Create a new thread by forking from a specific timeline entry in an existing thread. The forked thread starts at the chosen message, allowing you to split a conversation into a separate support case. Requires the thread:create permission. Arguments: - input: ForkThreadInput!

generateHelpCenterArticle

ChatGPT
Use AI to generate one or more draft help center articles from the content of a support thread. Returns the generated articles in DRAFT status for review before publishing. Requires the helpCenter:edit permission. Arguments: - input: GenerateHelpCenterArticleInput!

generatedReplies

ChatGPT
This API is in beta and may change without notice. Returns the current suggested reply candidates for a thread, scoped to the most recent inbound message from the customer or from a machine user. Externally submitted suggestions are always included. Suggestions generated by Plain AI are excluded when suggested responses are disabled or not available for the workspace, or when an externally submitted suggestion exists for the same message. Returns an empty list if the thread has no such message or no suggestion is available. Requires the generatedReply:read permission. Arguments: - threadId: ID! - options: [GenerateReplyOption!]

getAttachmentDownloadUrl

ChatGPT
Generate a short-lived download URL for an attachment on a thread. The attachment ID identifies an attachment on a thread timeline entry, such as a NoteEntry, ChatEntry, EmailEntry or SlackMessageEntry. The returned downloadUrl expires after 3 minutes. If attachmentVirusScanResult is INFECTED or FAILED, do not download the file. A null attachmentVirusScanResult means virus scanning is not enabled for the workspace. Requires the attachment:download permission.

getBroadcastAudienceDetails

ChatGPT
Fetch a single broadcast audience by its ID, or null if no audience with that ID exists. Returns soft-deleted audiences (where isDeleted is true), so the record of what a past broadcast was sent to survives. In filters, dimensions on one node AND together and values within a dimension OR. slackChannels are channels pinned by ID; the slackChannelNameContains substrings are re-resolved at send time. An audience with no filters at all means every tenant. type is fixed at creation and must match the type of any broadcast the audience is attached to. Audience IDs start with ba_.

getBroadcastAudiences

ChatGPT
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_.

getBroadcastDetails

ChatGPT
Fetch a single broadcast by its ID, including its authored content and who it is targeted at. Returns null if no broadcast with that ID exists, and returns soft-deleted broadcasts (where isDeleted is true). content is encoded as contentFormat says: TIPTAP is a serialised Tiptap JSON document (what the Plain app writes); SLACK_BLOCK_KIT is a JSON array of Slack blocks. Neither is plain text or markdown. sendTarget is who the broadcast reaches, resolved to concrete channels at send time rather than now. scope: ALL_RECIPIENTS means every connected, enabled customer channel and carries no filters; scope: MATCHING means only what filters selects. recipients are channels named outright and added to whatever filters resolves to; excludeRecipients are subtracted last. Inside filters, dimensions on one node AND together and values within a dimension OR. audienceIds reference saved audiences. appendUnsubscribeLink is the per-broadcast override for whether Plain appends an unsubscribe footer when this broadcast is delivered. Null inherits the workspace default; true or false overrides that default for this broadcast only. It controls footer emission, not whether unsubscribes are honoured. latestSend is the most recent non-test send, and where progress lives. Broadcast IDs start with bc_, audience IDs with ba_.

getBroadcastSendDeliveries

ChatGPT
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. The send has an isTest field that distinguishes test from real sends. 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. The counts summarize these deliveries without all recipient rows. edges is empty when the broadcast has no send with that id. Broadcast IDs start with bc_, send IDs with bcs_, delivery IDs with bcsd_.

getBroadcastSendTargetRecipients

ChatGPT
Preview who a broadcast send target resolves to right now — the live filter-to-recipient count, not a past send. Use this to answer "how many channels would get this?" and "why is the count zero?" before a human schedules the real send. Point-in-time: the number moves as tenants, tiers, tenant fields and connected channels change. Resolved through the same path a send uses, so it is what would actually be delivered to rather than an estimate assembled another way. Unsubscribed channels are excluded from count the same way a real send excludes them. Required input: type (must be SLACK) and sendTarget. - sendTarget.scope: ALL_RECIPIENTS means every connected, enabled customer channel and rejects filters. scope: MATCHING requires filters. Omit scope to target only channels named in recipients. - Inside filters, dimensions on one node AND together and values within a dimension OR. audienceIds reference saved audiences. - recipients are channels named outright and added to whatever filters resolves to; excludeRecipients are subtracted last. When count is zero, emptyReason explains the result. An opt-out can also cause NO_RECIPIENTS_RESOLVED: - NO_TENANTS_MATCHED — the filter itself matched no tenants. - NO_RECIPIENTS_RESOLVED — nothing reachable remained. That includes disabled / disconnected channels, and also every pin-by-id match (filters.slackChannels or named recipients) having opted out. Name / tenant filters usually surface the same opt-out as ALL_RECIPIENTS_UNSUBSCRIBED instead. An opt-out is not a broken connection. - EXCLUDED_BY_AUDIENCE — something matched, then the target's own exclusions removed all of it. - ALL_RECIPIENTS_UNSUBSCRIBED — something matched, and every channel it would have reached has opted out. Resubscription is available in the Plain app at https://app.plain.com/workspace/{workspaceId}/broadcasts/unsubscribes. recipients pages the channels that remain after unsubscribes are excluded. Use searchQuery to find one by name without changing count. 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. This live preview does not describe the recipients or opt-outs of a past send.

getBroadcastSends

ChatGPT
Fetch the send history of one broadcast, newest first. Use this to answer "has this broadcast gone out, and how far did each run get". One send is one run of the broadcast. A broadcast that has been sent once and tested twice has three sends. Test sends post real messages and collect real deliveries, and have isTest: true; isTest: false excludes test sends. statuses narrows to sends in particular states; DRAFT is not one of them, since it describes a broadcast with no send rather than a send. Omit a filter to leave that dimension unconstrained — an empty list is rejected. deliveryCounts is how far a send got, summarised across its recipients. It summarizes the send regardless of the number of recipients. skippedUnsubscribed is channels matched at resolve time but not posted because they opted out; it is recorded separately and is not part of total. 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 20). Broadcast IDs start with bc_, send IDs with bcs_.

getBroadcastUnsubscribeLinkSetting

ChatGPT
Read whether this workspace appends an unsubscribe link to outgoing broadcasts by default. This is emission-only: it controls whether the footer link is rendered on delivered messages. It does not enable or disable unsubscribes themselves — channels can still be opted out, including through the public link, and audience resolution always honours existing unsubscribes regardless of this setting. Precedence when a broadcast is delivered: 1. If the broadcast has an explicit appendUnsubscribeLink override, that value wins for that broadcast only. 2. Otherwise this workspace default applies. Null on the broadcast means "inherit this setting". The default for a new workspace is false (no footer).

getCustomerDetails

ChatGPT
Fetch detailed information about a specific customer by their ID. Returns the customer's profile including email, avatar, assignment, and timestamps. Also returns up to 5 accounts the customer belongs to, each with its tier name.

getCustomerThreads

ChatGPT
Fetch first 10 threads for a specific customer. Use this to see a customer's full support history. Optionally filter by status or sort by different criteria. 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 10). Thread URL format: https://app.plain.com/workspace/{workspaceId}/thread/{threadId}/ where {threadId} is the thread id field on each result (starts with th_) and {workspaceId} is the workspace ID (starts with w_).

getHelpCenterArticleGroups

ChatGPT
Fetch a paginated list of article groups for a specific help center. 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).

getHelpCenterArticles

ChatGPT
Fetch a paginated list of articles for a specific help center. 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). Each article's url is its public link to send customers; it is null unless the article is PUBLISHED.

getKnowledgeGapDetails

ChatGPT
Fetch a specific knowledge gap by its ID, including its task and the threads where customers hit it. Each signal's threadId identifies a thread where Ari, or the workspace's own agent through the API, could not answer the customer. Use signalsCursor with the endCursor from the previous response's signals pageInfo to fetch more signals. The cursor is an opaque token: pass it back unchanged and do not construct, modify, or alter it. The linked task controls the gap status. DONE records a completed gap; CANCELLED records a gap that will not be addressed.

getKnowledgeGaps

ChatGPT
Fetch knowledge gaps: questions customers ask that Ari, Plain's AI agent, could not answer from the workspace's knowledge sources. Each gap is detected from Ari replies. A task is raised on a gap's second hit and the gap's status follows that task. Gaps hit once have no task and no status filter returns them. By default, returns only open gaps (TODO, which includes IN_PROGRESS tasks), most frequently hit first. To include all gaps, pass statuses: null. To see the most recently hit gaps, pass sortBy: { field: LAST_SEEN_AT, direction: DESC }. To scope to a time window, pass lastSeenAt with ISO 8601 bounds, e.g. { after: "2026-10-12T00:00:00Z" } for gaps hit at least once since then. signals.totalCount is how many times customers have hit the gap, all time, even when lastSeenAt is set. 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 25).

getLabels

ChatGPT
Fetch a paginated list of label types from Plain. Each result includes its label type ID. Results exclude archived labels by default. isExcludedFromAi true means AI must never apply the label type. 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).

getMSTeamsMembersForChannel

ChatGPT
Fetches the current members of a Microsoft Teams channel directly from the Teams API. Requires a workspace MS Teams integration and calls Microsoft Graph; use this to populate member lists when resolving customers for a channel. Arguments: - msTeamsChannelId: ID! - msTeamsTeamId: ID!

getMyAssignedThreads

ChatGPT
Fetch first 10 threads assigned to a specific user in Plain. By default, returns only active threads (TODO and SNOOZED), excluding DONE threads. To include all threads regardless of status, pass statuses: null. To filter by specific statuses, pass an array like statuses: [TODO, DONE]. 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 10). Thread URL format: https://app.plain.com/workspace/{workspaceId}/thread/{threadId}/ where {threadId} is the thread id field on each result (starts with th_) and {workspaceId} is the workspace ID (starts with w_).

getMyUser

ChatGPT
Get the currently authenticated user's details. This query uses implicit authentication - no parameters are needed. Returns the user associated with the current session.

getMyWorkspace

ChatGPT
Get the currently authenticated user's workspace details. This query uses implicit authentication - no parameters are needed. Returns the workspace associated with the current session. The returned id (e.g. w_01G0EZ1XTM37C5X11SQTDNCTM1) is the workspace ID required to construct Plain dashboard URLs, e.g.: - Thread: https://app.plain.com/workspace/{workspaceId}/thread/{threadId}/

getSidekickSession

ChatGPT
Read a Sidekick session's status, newest messages, and approval requests. discussionId is the discussion handle, with prefix thdis_. last returns the newest N messages, with a default of 10. before accepts the preceding page's pageInfo.startCursor to return older messages. The cursor is opaque and must remain unchanged. A null discussion means no discussion with that ID is visible in the workspace. It is not a transient session state. A ThreadDiscussionApprovalRequestEntryPayload with status PENDING identifies an unresolved approval. Its justification and decoded calls describe the request. The approval card and approval share a transaction; projected session status can lag. Approval decisions take place in the Plain dashboard. agentStatus: TOOL_CALL_APPROVAL_PENDING can also represent a question that awaits an answer in the Plain app. Without a PENDING approval card, it does not identify an approval to resolve. IN_PROGRESS means the agent has an active turn; IDLE means the turn stopped; UNKNOWN means no turn started yet. Session status is OPEN or RESOLVED and describes the discussion lifecycle. The newest ThreadDiscussionMessageEntryPayload with isFinal: true contains the answer for that turn. queuedAgentSessionMessages contains messages not yet accepted into the active turn and clears when the agent accepts them. Customer reply drafts occur within <suggestedReply></suggestedReply>; text outside these tags is the agent's accompanying note. Session errors are not projected onto the discussion, so a failed session can look like one that has not started. The Plain dashboard contains the session details. entryType or __typename identifies the entry union member. Tool-call arguments are omitted because they can contain customer data.

getSnippets

ChatGPT
Fetch a paginated list of snippets from the workspace. Snippets are reusable reply templates that agents insert when composing replies. Soft-deleted snippets are excluded from this list. 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). Snippet IDs start with sn_.

getTaskDetails

ChatGPT
Fetch detailed information about a specific task by its ID. Returns the task's status, priority, 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 carry only a threadId. Thread URL format: https://app.plain.com/workspace/{workspaceId}/thread/{threadId}/ where {workspaceId} is the workspace ID (starts with w_).

getTaskDetailsByRef

ChatGPT
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, 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 carry only a threadId. Thread URL format: https://app.plain.com/workspace/{workspaceId}/thread/{threadId}/ where {workspaceId} is the workspace ID (starts with w_).

getThreadDetails

ChatGPT
Fetch complete details for a specific thread including first 50 timeline entries. Includes the customer, the thread's account (with its tier) and the thread's tier, so no follow-up calls are needed for them. Timeline entries include notes, chats, emails, status changes, assignments, and more. serviceLevelAgreementStatusSummary is the thread's current SLA status for each target (first response, next response, first resolution, total resolution). Each value is null when that target does not apply. __typename is the status: Pending, ImminentBreach, Breaching, Achieved, Breached, or Cancelled. Use the timelineCursor variable with the endCursor from the previous response's pageInfo to fetch the next page of timelineEntries. The cursor is an opaque token: pass it back unchanged and do not construct, modify, or alter it. Set timelineFirst to control page size (default 50). For email entries, textContent and markdownContent hold only the most recent reply with quoted history stripped. When hasMoreTextContent or hasMoreMarkdownContent is true, the full content including the quoted reply history is available via fullTextContent and fullMarkdownContent. Thread URL format: https://app.plain.com/workspace/{workspaceId}/thread/{threadId}/ where {threadId} is the thread id returned by this query (starts with th_) and {workspaceId} is the workspace ID (starts with w_).

getThreadFieldSchemas

ChatGPT
Fetch a paginated list of thread field schemas from Plain. Thread field schemas define the custom fields available for threads in your workspace. 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).

getThreads

ChatGPT
Fetch threads with flexible filtering options. Use this to find first 10 threads by status, status details, assignee, customer, tenant, labels, priority, date ranges, CSAT survey response, or any SLA tracker status. Each thread includes its customer, account (id, name) and tier (id, name). Set isAssigned: false to get unassigned threads. Set isAssigned: true to get assigned threads. Pass null for isAssigned to get all threads regardless of assignment. statusDetails filters by specific status detail types like CREATED, IN_PROGRESS, NEW_REPLY, WAITING_FOR_CUSTOMER, etc. 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 10). threadFields filters by custom thread field values. Keys and types correspond to the workspace's thread field schemas. Every entry must include key, stringValue, and booleanValue, then set exactly one value family to match on and leave the others as null: - STRING/ENUM: stringValue: "some value", booleanValue: null - BOOLEAN: stringValue: null, booleanValue: true - NUMBER: stringValue: null, booleanValue: null, number: { value: 5, gte: null, lte: null } equality number: { value: null, gte: 1, lte: 10 } range - DATE: stringValue: null, booleanValue: null, date: { after: "2024-01-01T00:00:00Z", before: null } For number/date, every sub-field must be present; null out the ones you are not matching on. Multiple entries are combined with OR; thread-field filtering is combined with the other filters above using AND. Example: threadFields: [{ key: "plan_tier", stringValue: "enterprise", booleanValue: null }] tenantIdentifiers filters by the tenant stamped on the thread. Each tenant identifier accepts a Plain id (starts with te_) or an externalId. Each entry must set exactly one of tenantId or externalId; omit the unused field or set it to null. Multiple entries are combined with OR. Example: tenantIdentifiers: [{ tenantId: "te_01..." }] tenantIdentifiers: [{ tenantId: "te_01...", externalId: null }] tenantIdentifiers: [{ externalId: "acme-prod" }] Threads created before the customer was added to the tenant may be missing. Current customer membership can differ from the tenant stamped on older threads. surveyResponse filters by CSAT survey response; set only the fields you are matching on. hasResponse: false matches threads sent a survey with no response. Examples: surveyResponse: { hasResponse: true } surveyResponse: { sentiment: NEGATIVE, responseAt: { after: "2024-01-01T00:00:00Z" } } slaStatuses and slaTypes match any SLA tracker status on the thread, including a completed one. A next-response or total-resolution target can keep an older BREACHED row after a newer PENDING tracker is created; slaStatuses: [BREACHED] still returns that thread. Leave a variable null to ignore that dimension. Statuses: PENDING, IMMINENT_BREACH, BREACHING, BREACHED, ACHIEVED, CANCELLED. Types: FIRST_RESPONSE_TIME, NEXT_RESPONSE_TIME, FIRST_RESOLUTION_TIME, TOTAL_RESOLUTION_TIME. Examples: slaStatuses: [BREACHING] slaStatuses: [BREACHING, IMMINENT_BREACH], slaTypes: [FIRST_RESPONSE_TIME] serviceLevelAgreementStatusSummary on each thread is the newest sla status per target, which can differ from a historical row the filter matched. A target is null when it does not apply. Thread URL format: https://app.plain.com/workspace/{workspaceId}/thread/{threadId}/ where {threadId} is the thread id field on each result (starts with th_) and {workspaceId} is the workspace ID (starts with w_).

githubUserAuthIntegration

ChatGPT
Returns the GitHub user authentication integration for the currently authenticated user, or null if no integration exists.

graphql

ChatGPT
Sends a GraphQL request to Plain's API as the person. Used by Plain's MCP App views.

helpCenter

ChatGPT
Fetch a single help center by ID. Returns null if not found. Arguments: - id: ID!

helpCenterArticle

ChatGPT
Fetch a single help center article by ID. Returns null if not found. url is the article's public link to send customers; it is null unless the article is PUBLISHED. Deleting an article is done by the user in the Plain app. The Plain app page is https://app.plain.com/workspace/w_…/help-center/<helpCenterId>/articles/<articleId>. Arguments: - id: ID!

helpCenterArticleBySlug

ChatGPT
Fetch an article by its URL slug within a specific help center. Slugs are unique per help center. Returns null if no article matches. url is the article's public link to send customers; it is null unless the article is PUBLISHED. Arguments: - helpCenterId: ID! - slug: String!

helpCenterArticleGroup

ChatGPT
Fetch a single article group by ID. Returns null if not found. Arguments: - id: ID!

helpCenterArticleGroupBySlug

ChatGPT
Fetch an article group by its URL slug within a specific help center. Returns null if no group matches. Arguments: - helpCenterId: ID! - slug: String!

helpCenterIndex

ChatGPT
Fetch the navigation index for a help center by its ID: every heading, article group and article in sidebar order, with its type, id, parent and title. Returns null if not found. A large help center's index is returned in one response, so this keeps to what an index needs. The index does not include each article's slug, description or content. The returned hash identifies the current snapshot. Index updates require this hash and every item as { type, entityId: id, parentId, title }; a stale hash fails the update.

helpCenters

ChatGPT
List all help centers in the workspace. Supports cursor-based pagination and optional filtering. Custom JavaScript, sign-in, access, the type and the subdomain of an existing help center are set by the user in the Plain app. The Plain app page is https://app.plain.com/workspace/w_…/help-center/<helpCenterId>, or …/help-center/create for a new help center that needs them. The user sets or clears a custom domain at https://app.plain.com/workspace/w_…/help-center/<helpCenterId>/domains; replace w_… and <helpCenterId> with the workspace and help center IDs. Cursor pagination supports first and after; a page size of 50 limits response size. Arguments: - first: Int - after: String - last: Int - before: String - filters: HelpCentersFilter

importJobDefinition

ChatGPT
Fetch the import job definition for a connected service integration. Pass isEnabled: true to return only the currently active definition, or isEnabled: false to return any definition regardless of enabled state. Returns null if no matching definition exists. Arguments: - serviceIntegrationKey: String! - isEnabled: Boolean

importJobs

ChatGPT
List import jobs, optionally filtered by service integration key or import job definition ID. Each job is a single sync run of an import job definition, with a run per entity type showing its progress, status and timing. Each job carries its whole run history, so a page holds 10 jobs unless you pass a different first. Page on with after.

indexedDocuments

ChatGPT
List indexed documents across your workspace, newest first. Use the knowledgeSourceId filter to retrieve only the documents belonging to a specific knowledge source, and the statuses filter to retrieve only documents with a given ingestion status. Cursor pagination supports first and after; a page size of 50 limits response size. Arguments: - first: Int - after: String - last: Int - before: String - filters: IndexedDocumentsFilter

interpolationVariables

ChatGPT
List the static variables that can be interpolated with {{ key }} in snippets, auto-responses, bulk replies and workflow actions, with a label and group for building a picker. Thread field variables are not included; derive them from the thread field schemas as threadField.<key>. Requires the workspace:read permission.

issueTrackerFields

ChatGPT
Fetch the configurable fields for a connected issue tracker (e.g. Shortcut, Rootly, incident.io, GitHub). Pass previously selected field values in selectedFields so that dependent fields (such as labels that depend on a chosen repository) are populated correctly. Returns the required and optional issue fields. Requires the threadLinkCandidate:search permission. Arguments: - issueTrackerType: String! — One of github_issue, shortcut_issue, incidentio_incident or rootly_incident. - selectedFields: [SelectedIssueTrackerField!]!

knowledgeSource

ChatGPT
Fetch a single knowledge source by its ID. Returns null if no knowledge source with the given ID exists. Arguments: - knowledgeSourceId: ID!

knowledgeSourceCitationsByThread

ChatGPT
Returns the knowledge sources cited by AI agent replies across a thread, each linked to the timeline entry it was cited in and carrying a snapshot title (and best-effort url) plus the live cited document when it still exists. Returns an empty list when the thread has no citations or is not visible to the caller. Requires the thread:read and timeline:read permissions. Arguments: - threadId: ID!

knowledgeSources

ChatGPT
List all knowledge sources in the workspace. Use the type filter to retrieve only sitemap or single-URL sources. Cursor pagination supports first and after; a page size of 50 limits response size. Arguments: - first: Int - after: String - last: Int - before: String - filters: KnowledgeSourcesFilter

labelType

ChatGPT
Returns a single label type by its ID. Returns null if no label type with that ID exists. Requires the labelType:read permission. Team assignment settings, such as round-robin capacity, are separate from the label type. Arguments: - labelTypeId: ID!

labelTypeByExternalId

ChatGPT
Returns a label type by its external ID. Returns null if no match is found. External IDs are unique within a workspace and are set when creating or updating a label type. Requires the labelType:read permission. Arguments: - externalId: ID!

linearAppIntegration

ChatGPT
The workspace-level Linear app integration, if one has been authorised. Not connected yet? Connecting needs the user's approval in the provider. The Plain app page is https://app.plain.com/workspace/w_…/install/linear.

listSidekickSessions

ChatGPT
List Sidekick sessions in the workspace, most recent activity first. The first session is the most recently active one, even when its last-activity time is empty. Use this to resume a session from an earlier conversation, to check whether a session you started actually landed after a timeout, or to find sessions that need attention. Pass agentStatuses: [TOOL_CALL_APPROVAL_PENDING] to list only the sessions currently blocked on a human approval decision (or, for sessions started in the Plain app, on a question waiting to be answered there), or agentStatuses: [IN_PROGRESS] for the ones still working. statuses is the session's own lifecycle and is only ever OPEN or RESOLVED. agentStatuses does not filter by it, so combine the two to exclude closed sessions. Pass createdByUserIds with your own user id to list only your sessions. Use the after variable with pageInfo.endCursor from the previous response to page. The cursor is an opaque token: pass it back unchanged and do not construct, modify, or alter it. Only agent sessions are returned, both Plain's own Sidekick and any agent the workspace built itself. Each id (starts with thdis_) is the session discussion handle. A session run by an agent the workspace built has a null agentSessionId, because Plain runs no session for one; its discussion remains available for messages and replies.

lockThread

ChatGPT
Lock a thread to prevent further replies or changes by non-admin users. Use this when a resolution is final and you want to freeze the conversation. Requires the thread:edit permission. Arguments: - input: LockThreadInput!

machineUser

ChatGPT
Fetches a single machine user by ID. Returns null if no machine user with the given ID exists in the workspace. API keys and their permissions are separate from this machine-user result and require the apiKey:read permission. Deleting a machine user, and creating, changing or deleting its API keys, are done by the user in the Plain app, so a key's secret never passes through an agent. The Plain app page is https://app.plain.com/workspace/w_…/settings/machine-users/<machineUserId>, or …/api-keys/add and …/api-keys/<apiKeyId> under it for keys.

machineUserApiKeys

ChatGPT
Lists a machine user's API keys with each key's permissions. Requires the apiKey:read permission. Creating, changing and deleting API keys are done by the user in the Plain app, so a key's secret never passes through an agent. The Plain app page is https://app.plain.com/workspace/w_…/settings/machine-users/<machineUserId>/api-keys/add, or …/api-keys/<apiKeyId> for an existing key.

machineUsers

ChatGPT
Returns a paginated list of all machine users in the workspace. Use the optional filters.type argument to restrict results to a specific machine user type (e.g. API_USER or AI_AGENT). Deleting a machine user, and creating, changing or deleting its API keys, are done by the user in the Plain app, so a key's secret never passes through an agent. The Plain app page is https://app.plain.com/workspace/w_…/settings/machine-users/<machineUserId>, or …/api-keys/add and …/api-keys/<apiKeyId> under it for keys. Cursor pagination supports first and after; a page size of 50 limits response size. Arguments: - filters: MachineUsersFilter - first: Int - after: String - last: Int - before: String

markCustomerAsSpam

ChatGPT
Flags a customer as spam, hiding their threads from the inbox and excluding them from metrics. The operation is idempotent — marking an already-spam customer leaves their markedAsSpamAt timestamp unchanged. Requires the customer:edit permission. Arguments: - input: MarkCustomerAsSpamInput!

markThreadAsDone

ChatGPT
Mark a thread as Done, indicating there is nothing left for the support team to do right now. The thread will automatically revert to Todo when new activity arrives. Requires the thread:edit and thread:read permissions. Arguments: - input: MarkThreadAsDoneInput!

markThreadAsTodo

ChatGPT
Explicitly move a thread back to Todo status. Use this to unsnooze a thread early or to reopen a thread that was incorrectly marked as Done. Requires the thread:edit and thread:read permissions. Arguments: - input: MarkThreadAsTodoInput!

mergeThread

ChatGPT
Merge one Plain thread into another (a MERGED_INTO native thread link). The child thread (childThreadId) is merged into the parent thread (parentThreadId). On success the child thread is marked as done and the merge link is returned. The same guardrails as in-app merging apply and surface as standard mutation errors, including: a thread cannot be merged into itself, no circular links, a child that is already merged into another thread cannot be merged again, a thread that already has children merged into it cannot itself be merged, and the parent cannot already be merged into another thread.

moveLabelType

ChatGPT
Changes the position of a label type in the ordered list, or moves it to a different parent. Supply afterLabelTypeId or beforeLabelTypeId to place the label type relative to a sibling, and optionally parentLabelTypeId to nest it under a parent. Requires the labelType:edit permission. Arguments: - input: MoveLabelTypeInput!

moveWorkflow

ChatGPT
Move a workflow so it sits directly after another, or to the front of the list when afterWorkflowId is null. Only the moved workflow changes. Arguments: - input: MoveWorkflowInput!

myBillingRota

ChatGPT
Returns the current billing rota for the workspace, listing which users are actively on-rota and which are off-rota. The rota is used to track which users currently consume an active eng-rota seat.

myBillingSubscription

ChatGPT
Returns the current workspace billing subscription, including plan, status, trial info, feature entitlements, and credit balances. Returns null if the workspace has no billing account.

myEmailSignature

ChatGPT
Returns the email signature configured for the currently authenticated user, or null if none has been set.

myFavoritePages

ChatGPT
Returns the favorite pages saved by the currently authenticated user, ordered by most recently created first. Each user's favorites are independent — this query only returns pages belonging to the caller. Cursor pagination supports first and after; a page size of 50 limits response size. Arguments: - first: Int - after: String - last: Int - before: String

myInternalNotifications

ChatGPT
Returns a paginated list of internal notifications for the currently authenticated user. Use the optional filters argument to narrow results by read status or creation time. Supports forward and backward cursor-based pagination via first/after and last/before. Only available to human users — machine users will receive a forbidden error. Cursor pagination supports first and after; a page size of 50 limits response size. Arguments: - filters: InternalNotificationsFilter - first: Int - after: String - last: Int - before: String

myLinearIntegration

ChatGPT
Returns the current user's Linear integration, or null if no integration has been set up.

myMSTeamsIntegration

ChatGPT
Returns the Microsoft Teams integration for the currently authenticated user, or null if the user has not connected their account.

myPermissions

ChatGPT
Returns the full list of permission strings granted to the currently authenticated user or machine user in this workspace. Useful for inspecting what actions the caller is authorized to perform.

mySlackIntegration

ChatGPT
Returns the current user's personal Slack notifications integration, or null if none is connected.

myUserAccount

ChatGPT
Returns the UserAccount for the currently authenticated user, or null if no account has been created yet. Useful during onboarding to check whether account setup is complete.

myWorkspaceInvites

ChatGPT
Returns all pending workspace invites sent to the currently authenticated user's email address. Use this to let a user see and act on workspaces they have been invited to join. Cursor pagination supports first and after; a page size of 50 limits response size. Arguments: - first: Int - after: String - last: Int - before: String

myWorkspaces

ChatGPT
Returns all workspaces the currently authenticated human user belongs to, paginated. Not available to machine users. Use this to let users switch between workspaces. Cursor pagination supports first and after; a page size of 50 limits response size. Arguments: - first: Int - after: String - last: Int - before: String

permissions

ChatGPT
Returns the complete list of all permission strings defined in Plain, sorted alphabetically. Use this to discover valid permission values when building role or API key management UIs. Requires the permission:read permission.

rearrangeLabelTypes

ChatGPT
Moves and reorders many label types in one operation. Each sibling group sets the order of the label types under one parent, and listing a label type under a different parent moves it there. All changes are applied together or not at all, and only label types whose parent or position changes are updated. Requires the labelType:edit permission. Arguments: - input: RearrangeLabelTypesInput!

refreshConnectedDiscordChannels

ChatGPT
Syncs the list of Discord channels for a guild from the Discord API into Plain. The synced list reflects channels added or renamed in Discord. Arguments: - input: RefreshConnectedDiscordChannelsInput!

reindexKnowledgeSource

ChatGPT
Trigger an immediate re-index of a knowledge source. Use this when the source content has changed and you do not want to wait for the automatic weekly re-index. The knowledge source status is reset to pending and indexing is queued asynchronously. Requires Plain AI to be enabled on the workspace. Arguments: - input: ReindexKnowledgeSourceInput!

relatedThreads

ChatGPT
Find threads that are semantically similar to the given thread, ranked by relevance. Each result includes the thread and a distance score (lower means more similar). Useful for surfacing related support history or finding duplicate issues. Requires the thread:read permission. Arguments: - threadId: ID!

reloadCustomerCardInstance

ChatGPT
Forces a fresh load of a customer card instance, bypassing the cache. Use this when you know your external data has changed and you want to immediately fetch updated card content from your API URL. The response will be a CustomerCardInstanceLoading; the load completes asynchronously with a loaded or errored result. Arguments: - input: ReloadCustomerCardInstanceInput!

removeAccountFieldSchemaMapping

ChatGPT
Removes the mapping between an account field schema and a built-in Plain concept, disabling any automatic behaviour (such as tier assignment) driven by that field. Arguments: - input: RemoveAccountFieldSchemaMappingInput!

removeAdditionalAssignees

ChatGPT
Remove one or more additional assignees from a thread. Does not affect the primary assignee. Requires the thread:unassign and thread:read permissions. Arguments: - input: RemoveAdditionalAssigneesInput!

removeCustomerFromAccounts

ChatGPT
Removes a customer from one or more accounts. The customer can be identified by their Plain ID, external ID, or email address. If the customer is not currently a member of a specified account the operation is a no-op for that account. Requires the customer:edit and customerTenantMembership:delete permissions. Arguments: - input: RemoveCustomerFromAccountsInput!

removeCustomerFromTenants

ChatGPT
Removes a customer from one or more tenants. The customer can be identified by their Plain ID, external ID, or email address. If the customer is not currently a member of a specified tenant the operation is a no-op for that tenant. Requires the customer:edit and customerTenantMembership:delete permissions. Deprecated. Arguments: - input: RemoveCustomerFromTenantsInput!

removeLabels

ChatGPT
Remove one or more labels from a thread by label ID. All provided label IDs must belong to the same thread; mixing labels from different threads returns an error. Requires the label:delete permission. Arguments: - input: RemoveLabelsInput!

removeLabelsFromUser

ChatGPT
Remove one or more labels from a Plain user (agent) by label ID. Returns the remaining labels still applied to the user after the removal. Requires the label:delete permission. Arguments: - input: RemoveLabelsFromUserInput!

removeMembersFromTier

ChatGPT
Removes one or more tenants or companies from their current tier (up to 25 per call). After removal the member has no tier. Requires the tierMembership:read and tierMembership:delete permissions. Arguments: - input: RemoveMembersFromTierInput!

removeTenantFieldSchemaMapping

ChatGPT
Removes the mapping between a tenant field schema and a built-in Plain concept, disabling any automatic behaviour (such as tier assignment) driven by that field. Deprecated. Arguments: - input: RemoveTenantFieldSchemaMappingInput!

reorderCustomerCardConfigs

ChatGPT
Updates the display order of one or more customer card configs. Only the configs listed in the input are updated; other configs keep their current order. This allows you to swap two configs or move a single card without specifying the full list. Duplicate order values are permitted and ties are broken by ID. Arguments: - input: ReorderCustomerCardConfigsInput!

reorderCustomerSurveys

ChatGPT
Updates the display order of one or more customer surveys in a single call. Pass an array of survey ID / order-index pairs; only surveys whose order actually changes are updated. Duplicate survey IDs in the input are rejected. Requires the customerSurvey:edit permission. Arguments: - input: ReorderCustomerSurveysInput!

reorderThreadFieldSchemas

ChatGPT
Updates the display order of thread field schemas. You only need to include schemas whose order is changing — omitted schemas are left unchanged. Arguments: - input: ReorderThreadFieldSchemasInput!

replyToEmail

ChatGPT
Replies to an existing email in a thread, threading the response correctly in email clients. Use inReplyToEmailId to identify the email being replied to. Supports CC and BCC recipients (up to 49 combined) and file attachments. Requires the email:create and email:read permissions. Arguments: - input: ReplyToEmailInput!

replyToThread

ChatGPT
Send a reply to the customer on a thread using the most appropriate channel automatically. Supports threads where the last inbound message is an email, a Slack message, or a form submission. If the thread has no messages yet, an email is sent to the customer. Requires the thread:reply (or channel-specific send) permission. Arguments: - input: ReplyToThreadInput!

resolveCustomerForSlackChannel

ChatGPT
Finds or creates a Plain customer associated with a Slack channel, using the Slack users in that channel to identify the customer. Useful for bootstrapping threads from Slack channels. Arguments: - input: ResolveCustomerForSlackChannelInput!

roles

ChatGPT
Returns the roles available in the workspace: the built-in roles (Owner, Admin, Support, Viewer, None) and any custom roles. Requires the roles:read permission. The user changes role priority for SSO or directory sync in the Plain app at https://app.plain.com/workspace/w_…/settings/roles; replace w_… with this workspace's ID. Each role's permission list, often hundreds of entries, is left out so every role fits on one page. Custom role presets and thread scopes are not included in this result.

savedThreadsView

ChatGPT
Fetches a single saved threads view by its ID. Returns null if no view with the given ID exists in the workspace. Arguments: - savedThreadsViewId: ID!

savedThreadsViews

ChatGPT
Returns all saved threads views for the workspace, ordered by creation time. Use this to list the views available in your workspace. Supports forward and backward cursor pagination. Cursor pagination supports first and after; a page size of 50 limits response size. Arguments: - first: Int - after: String - last: Int - before: String

scheduleBroadcast

ChatGPT
Queues a broadcast to be sent, moving it from DRAFT to SCHEDULED. Calling this again on a broadcast that has not started sending changes when it will go out; once the send has started it is rejected. The broadcast must have a sender and at least one channel. A null scheduledAt clears the schedule instead, returning the broadcast to DRAFT. Requires the broadcast:send and broadcast:read permissions. Arguments: - input: ScheduleBroadcastInput!

searchAccounts

ChatGPT
Searches accounts by name, domain, or external ID. The name matches when it contains the term. A match at the start of the name, or of a word in it, ranks ahead of a match inside a word. The domain matches when it contains the term. The external ID matches only in full. Matching is case-insensitive. The search term must be at least 2 characters long. Returns a paginated list of results. Requires the tenant:read permission. Cursor pagination supports first and after; a page size of 50 limits response size. Arguments: - searchQuery: AccountsSearchQuery! - filters: AccountsFilter - first: Int - after: String - last: Int - before: String

searchBroadcasts

ChatGPT
Searches broadcasts by name (case-insensitive partial match). Soft-deleted broadcasts are excluded. Optionally narrow the results with filters (status), which applies on top of the name match. Requires the broadcast:read permission. Cursor pagination supports first and after; a page size of 50 limits response size. Arguments: - searchQuery: BroadcastsSearchQuery! - filters: BroadcastsFilter - first: Int - after: String - last: Int - before: String

searchCustomers

ChatGPT
Search for customers by name, email, short name, or external ID. The search is case-insensitive and matches partial strings, returns first 50 results. Each customer includes up to 5 accounts it belongs to, each with its tier name. All fields are searched simultaneously with the same search term (OR logic). 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). tenantIdentifiers filters by current tenant membership. Each tenant identifier accepts a Plain id (starts with te_) or an externalId. Each entry must set exactly one of tenantId or externalId; omit the unused field or set it to null. Multiple entries are combined with OR. Example: tenantIdentifiers: [{ tenantId: "te_01..." }] tenantIdentifiers: [{ tenantId: "te_01...", externalId: null }]

searchKnowledgeSources

ChatGPT
Perform a semantic (vector) search across your workspace's knowledge sources and help center articles. Matches up to pageSize chunks (default 10, max 50), then returns one result per source containing its full indexed text, ordered by each source's most relevant chunk. Use options to restrict results by label type, content type (indexed documents vs help center articles), or to include help center articles that are not publicly accessible. For a help center article, helpCenterArticle.url is its public link: cite it as is when sending an article to a customer. It is null unless the article is PUBLISHED. Arguments: - searchQuery: String! - pageSize: Int - options: SearchKnowledgeSourcesOptions

searchPlainHelpCenter

ChatGPT
Perform a semantic (vector) search across Plain's own public help center (help.plain.com). Available to every workspace's Sidekick Agent so it can answer questions about how Plain itself works. Read-only and hard-restricted to Plain's public product documentation; it never returns the caller's own data or any other workspace's content. Returns up to pageSize results (default 10, max 50) ranked by relevance. Arguments: - searchQuery: String! - pageSize: Int

searchSlackUsers

ChatGPT
Searches for slack users in a slack channel based on a search term. The search term can be part of either the slack's handle or full name. Cursor pagination supports first and after; a page size of 50 limits response size. Arguments: - slackTeamId: String! - slackChannelId: String! - searchQuery: String! - first: Int - after: String - last: Int - before: String

searchTenants

ChatGPT
Search for tenants by name or external ID. The search is case-insensitive: partial match on name, exact match on external ID. The search term must be at least 2 characters long. 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).

searchThreadLinkCandidates

ChatGPT
Searches issue trackers (GitHub issues, Shortcut stories, incident.io and Rootly incidents) for issues that can be linked to a thread. Filter by sourceType to scope the search to a specific issue tracker, and provide a free-text searchQuery to match against issue titles or identifiers. Returns possible thread link targets. Requires a connected issue tracker integration for the specified source type. Cursor pagination supports first and after; a page size of 50 limits response size. Arguments: - filters: ThreadLinkCandidateFilter! - searchQuery: String! — Free text matched against titles or identifiers. For github_issue, include repo:owner/repo. - first: Int - after: String - last: Int - before: String

searchThreadSlackUsers

ChatGPT
Searches for slack users in a thread based on a search term. The search term can be part of either the slack's handle or full name. Cursor pagination supports first and after; a page size of 50 limits response size. Arguments: - threadId: ID! - searchQuery: String! - first: Int - after: String - last: Int - before: String

searchThreads

ChatGPT
Search threads by text content in title, description, or messages. Returns the first 10 results by default; pass first (e.g. 50) for more. Optionally filter results by status, priority, customer, tenant, assignee, or labels. Each thread includes its customer, account (id, name) and tier (id, name). Each thread includes serviceLevelAgreementStatusSummary, the current SLA status for each target. A target is null when it does not apply. 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 10). tenantIdentifiers filters by the tenant stamped on the thread. Each tenant identifier accepts a Plain id (starts with te_) or an externalId. Each entry must set exactly one of tenantId or externalId; omit the unused field or set it to null. Multiple entries are combined with OR. Example: tenantIdentifiers: [{ tenantId: "te_01..." }] tenantIdentifiers: [{ tenantId: "te_01...", externalId: null }] tenantIdentifiers: [{ externalId: "acme-prod" }] Threads created before the customer was added to the tenant may be missing. Current customer membership can differ from the tenant stamped on older threads. Thread URL format: https://app.plain.com/workspace/{workspaceId}/thread/{threadId}/ where {threadId} is the thread id field on each result (starts with th_) and {workspaceId} is the workspace ID (starts with w_).

sendBulkEmail

ChatGPT
Sends the same email body to multiple threads at once (up to 100 thread IDs per call). Useful for broadcasting updates to a set of customers, for example notifying affected users of an incident. Arguments: - input: SendBulkEmailInput!

sendChat

ChatGPT
Send a chat message from a support agent (or machine user) to a customer on a CHAT-channel thread. Either text or at least one attachmentIds entry must be provided. If threadId is omitted a new thread is created; if supplied the message is appended to the existing thread. An optional timestamp (ISO 8601, must be in the past) allows backdating messages when backfilling historical data. Requires the chat:create permission and the live-chat billing entitlement. Arguments: - input: SendChatInput!

sendDiscordMessage

ChatGPT
Sends an outbound Discord message on a thread. Requires both a workspace-level Discord channel integration and a personal user auth integration for the sending user. The message is posted into the Discord thread associated with the Plain thread. Arguments: - input: SendDiscordMessageInput!

sendMSTeamsMessage

ChatGPT
Sends a Microsoft Teams message on a thread. The thread must be associated with a connected MS Teams channel and the workspace must have an active MS Teams integration. Arguments: - input: SendMSTeamsMessageInput!

sendNewEmail

ChatGPT
Sends a new outbound email to a customer, creating a new thread by default. Use threadId to attach the email to an existing thread instead. Supports CC and BCC recipients (up to 49 combined), file attachments, and an optional alternate from address. Requires the email:create and email:read permissions. Arguments: - input: SendNewEmailInput!

sendSidekickMessage

ChatGPT
Send a follow-up message into an existing Sidekick session. discussionId is the session discussion handle, with prefix thdis_. Use this to answer a question from Sidekick, redirect it, or give it the next task in the same session. Sidekick keeps the earlier conversation as context. If the session is idle the agent starts a new turn. If the agent is mid-turn the message is queued and picked up when the turn ends. A null discussionMessage together with a null error means the message was QUEUED, not that it failed. It remains in the session's queuedAgentSessionMessages until the agent picks it up. This tool returns as soon as the message is accepted.

sendSlackMessage

ChatGPT
Sends a Slack message on a thread. The message appears in the thread's associated Slack channel as a reply or new message. Arguments: - input: SendSlackMessageInput!

sendTestBroadcast

ChatGPT
Send a test copy of a broadcast to Slack channels you name, so you can see what recipients will get before the real audience does. This posts real messages into real channels. Everyone in the channels you name will see it. It carries a notice at the top marking it as a test, and it goes out through the same pipeline and under the broadcast's own sender, so what arrives is what any channel would have received. - channels takes between 1 and 10 { slackTeamId, slackChannelId } pairs. A channel ID is only unique within its Slack team, so both are needed. Every channel must already be connected to this workspace, and naming the same channel twice posts to it once. - The channels are independent of the broadcast's own audience, which is left untouched. The broadcast needs a sender and a notification title, but it does not need any channels of its own — testing is what you do before choosing them. - A test send never changes the broadcast's status, and never locks or unlocks editing. Only available while the broadcast can still be edited: once its real send has started, it can no longer be tested. The response includes the test send's ID. This does not schedule the real send. Queuing a broadcast to its actual audience is done by a human in the Plain app.

sendThreadDiscussionMessage

ChatGPT
Send a reply to an existing Slack or email discussion. The message is posted in the original channel (as a Slack thread reply or email reply) and recorded in Plain. For Slack discussions you may optionally provide slackBlocks, set unfurlLinks, or broadcast the reply into the parent channel via replyBroadcast (replyBroadcast cannot be combined with attachmentIds). Prefer sendDiscussionMessage for new integrations. Arguments: - input: SendThreadDiscussionMessageInput!

serviceAuthorization

ChatGPT
Fetch a single completed service authorization by its ID. Returns null if not found or if the authorization is still pending. Arguments: - serviceAuthorizationId: ID!

serviceAuthorizations

ChatGPT
List all completed service authorizations for the workspace. Only authorizations with status CONNECTED or REINSTALL_REQUIRED are returned; pending authorizations are excluded. Optionally filter by serviceIntegrationKey. Supports cursor-based pagination. Requires the serviceAuthorization:read permission. Not connected yet? Connecting needs the user's approval in the provider. The Plain app page is https://app.plain.com/workspace/w_…/settings/integrations. Cursor pagination supports first and after; a page size of 50 limits response size. Arguments: - first: Int - after: String - last: Int - before: String - filters: ServiceAuthorizationsFilter

serviceLevelAgreementPolicies

ChatGPT
Returns the SLA policies in the workspace, sorted by name. Pass filters to narrow by name, by the target types a policy holds, or by archived state; by default both active and archived policies are returned. Supports cursor-based pagination. Requires the serviceLevelAgreement:read permission. An archived policy cannot be assigned to new threads; existing threads retain their SLAs. Deleting a policy is done by the user in the Plain app. The Plain app page is https://app.plain.com/workspace/w_…/settings/slas/<policy id>. Cursor pagination supports first and after; a page size of 50 limits response size. Arguments: - filters: ServiceLevelAgreementPoliciesFilter - first: Int - after: String - last: Int - before: String

serviceLevelAgreementPolicy

ChatGPT
Returns a single SLA policy by its Plain ID. Returns null if no policy with that ID exists. Requires the serviceLevelAgreement:read permission. An archived policy cannot be assigned to new threads; existing threads retain their SLAs. Deleting a policy is done by the user in the Plain app. The Plain app page is https://app.plain.com/workspace/w_…/settings/slas/<policy id>. Arguments: - serviceLevelAgreementPolicyId: ID!

setCustomerAccounts

ChatGPT
Replaces the full set of account memberships for a customer in a single call. Any accounts not included in the input are removed; any new ones are added. Use this when syncing account membership from your own system rather than tracking individual add/remove changes. Requires the customer:edit, customerTenantMembership:create, and customerTenantMembership:delete permissions. Arguments: - input: SetCustomerAccountsInput!

setCustomerTenants

ChatGPT
Replaces the full set of tenant memberships for a customer in a single call. Any tenants not included in the input are removed; any new ones are added. Use this when syncing tenant membership from your own system rather than tracking individual add/remove changes. Requires the customer:edit, customerTenantMembership:create, and customerTenantMembership:delete permissions. Deprecated. Arguments: - input: SetCustomerTenantsInput!

setSlackAutoJoinRules

ChatGPT
Replaces all auto-join rules for a workspace slack channel integration. The provided rules become the complete set of rules for the integration. Arguments: - input: SetSlackAutoJoinRulesInput!

setupAccountFieldSchemaMapping

ChatGPT
Maps an account field schema to a built-in Plain concept such as TIER, enabling automatic tier assignment based on the field's value. Only one schema can be mapped to a given concept at a time. Arguments: - input: SetupAccountFieldSchemaMappingInput!

setupTenantFieldSchemaMapping

ChatGPT
Maps a tenant field schema to a built-in Plain concept such as TIER, enabling automatic tier assignment based on the field's value. Only one schema can be mapped to a given concept at a time. Deprecated. Arguments: - input: SetupTenantFieldSchemaMappingInput!

shareThreadToUserInSlack

ChatGPT
Sends a direct Slack message to a Plain user sharing a link to the given thread. Useful for notifying a teammate about a thread directly in Slack. Arguments: - input: ShareThreadToUserInSlackInput!

sidekickCreditBalance

ChatGPT
The workspace's current Sidekick (Plain) credit balance: the monthly allowance grant/used/remaining and when it resets, plus any purchased top-up remaining. Use it to answer how many credits are left. Requires the billing:read permission.

sidekickCreditUsageByDay

ChatGPT
Credit usage for the workspace, bucketed by the UTC day each billable item resolved, over the given date range. Covers Sidekick sessions and work done by the workspace's own agents. Use it to show a per-day breakdown of credit consumption. Requires the billing:read permission. Arguments: - input: SidekickCreditUsageByDayInput!

sidekickCustomSkill

ChatGPT
A single workspace custom skill, including its instructions, for editing. Arguments: - id: ID!

sidekickGithubAccessibleRepos

ChatGPT
Returns every GitHub repository the Sidekick Agent integration (identified by serviceAuthorizationId) can currently see via its OAuth token. The result identifies the repositories available for the integration's configuration. Arguments: - serviceAuthorizationId: ID!

sidekickGithubServiceConfig

ChatGPT
Returns the Sidekick Agent GitHub configuration for a workspace: which repositories are selected for Sidekick Agent to use and any workspace-level or per-repo operating instructions. Returns null when no configuration has been saved yet. Arguments: - serviceAuthorizationId: ID!

sidekickPosthogServiceConfig

ChatGPT
Returns the Sidekick Agent PostHog configuration for a workspace, including any operating instructions and the default project the agent queries. Returns null when no configuration has been saved yet. Arguments: - serviceAuthorizationId: ID!

sidekickServiceConfig

ChatGPT
Returns the Sidekick Agent configuration for a connected service (Datadog, Sentry, Grafana, Linear, Notion, incident.io, Attio, HubSpot, Jira, Granola, LaunchDarkly, Grain or Cursor), identified by its serviceAuthorizationId. Includes any operating instructions that guide how Sidekick Agent uses the integration. Returns null when no configuration has been saved yet. GitHub and PostHog use separate configuration shapes and are not covered by this result. Arguments: - serviceAuthorizationId: ID!

sidekickSettings

ChatGPT
Returns workspace-level Sidekick Agent settings, including the custom prompt that is appended to every Sidekick Agent session's system prompt and the tools selected during onboarding. Always returns an object. customPrompt is null when not configured. preferredIntegrations is empty when none are selected.

sidekickSkills

ChatGPT
Every skill available to Sidekick Agent in this workspace: Plain's system skills plus the workspace's custom skills, each with its effective enabled state.

slackAutoJoinRules

ChatGPT
Gets the auto-join rules for a workspace slack channel integration. Unsaved rules are read from the legacy prefix/suffix settings and have a null id. Arguments: - integrationId: ID!

slackUser

ChatGPT
Returns a Slack user within a specific channel, looked up by their Slack user ID. Returns null if the user is not found in that channel. Arguments: - slackTeamId: String! - slackChannelId: String! - slackUserId: ID!

snippet

ChatGPT
Fetches a single snippet by its ID, or null if no snippet with that ID exists. Returns soft-deleted snippets (where isDeleted is true). Requires the snippet:read permission. Arguments: - snippetId: ID!

snoozeThread

ChatGPT
Snooze a thread for a number of seconds or until the customer replies (set statusDetail to WAITING_FOR_CUSTOMER). A snoozed thread is automatically unsnoozed when new activity arrives or when the timer expires. Requires the thread:edit and thread:read permissions. Arguments: - input: SnoozeThreadInput!

startSidekickSession

ChatGPT
Start a new Sidekick session. Sidekick is Plain's AI agent and runs asynchronously in a sandbox. The tool returns when the session is created, before the agent answers. markdownContent is the task. Optional threadId attaches a Plain thread, with prefix th_, as context. Without it the session is standalone. additionalContext provides optional free-form context. The returned discussion.id, with prefix thdis_, identifies the session discussion. The returned agent session ID, with prefix as_, is informational and is not a discussion ID. A disabled-Sidekick or insufficient-credits error means the workspace cannot run Sidekick. The operation has no idempotency key. A retry after a timeout can create and bill a second sandbox session.

subscriptionEventTypes

ChatGPT
List every event type that can be subscribed to on a webhook target. Each entry includes the event type identifier and a human-readable description. Use this to discover valid values for eventSubscriptions when creating or updating a webhook target. Requires the subscriptionEventTypes:read permission.

suggestedLabelTypes

ChatGPT
Returns the PENDING AI-suggested label types awaiting review, most recently created first. Requires the suggestedLabelType:read permission.

suggestedSlackTeammates

ChatGPT
Suggests teammates to invite to Plain, sourced from the members of the workspace's connected Slack discussion channels. Only members of the workspace's own Slack team are included (Slack Connect guests are excluded), and anyone (matched by email, case-insensitive) who is already a member of this workspace or has a pending invite to it is excluded. Returns an empty list when there are no connected, enabled discussion channels for the given slackTeamId (e.g. a Slack Connect channel integration). Arguments: - slackTeamId: String!

syncUserWorkingHours

ChatGPT
Replace a user's working hours schedule in full. When isEnabled is true, the user's status is automatically switched to ONLINE at the start of each slot and to OFFLINE or AWAY (depending on workspace settings) at the end. Omit userId to configure the currently authenticated user's own schedule. Arguments: - input: SyncUserWorkingHoursInput!

tasks

ChatGPT
Fetch a paginated list of tasks in the workspace. Use filters to narrow results by status, assignee, company, or tenant. Use sortBy to order by priority, status, or creation/update time. Requires the task:read permission. Cursor pagination supports first and after; a page size of 50 limits response size. Arguments: - first: Int - after: String - last: Int - before: String - filters: TasksFilter - sortBy: TasksSort

teamSettings

ChatGPT
Fetch the settings for a team (label type of kind TEAM) identified by its label type ID. Returns null if no settings have been configured yet for the team. Arguments: - labelTypeId: ID!

tenant

ChatGPT
Fetches a single tenant by its Plain-assigned ID. Returns null if no matching tenant is found. Requires the tenant:read permission. Deprecated. Arguments: - tenantId: ID!

tenantFieldSchemas

ChatGPT
Returns the list of tenant field schemas defined in the workspace. Use the source and isVisible filters to narrow results. Supports cursor-based pagination. Deprecated. Cursor pagination supports first and after; a page size of 50 limits response size. Arguments: - filters: TenantFieldSchemasFilter - first: Int - after: String - last: Int - before: String

tenants

ChatGPT
Returns a paginated list of tenants in the workspace. Use the filters argument to narrow the results and sortBy to order them (by name ascending when omitted). Requires the tenant:read permission. Deprecated. Cursor pagination supports first and after; a page size of 50 limits response size. Arguments: - first: Int - after: String - last: Int - before: String - filters: TenantsFilter - sortBy: TenantsSort

testThreads

ChatGPT
The signed-in user's own test threads, oldest first. They are excluded from threads, so this is the only query that lists them. Requires the thread:read permission.

threadByExternalId

ChatGPT
Fetch a thread by the external ID you assigned it, scoped to a specific customer. Because externalId is only unique per-customer, both customerId and externalId are required. Returns null if no match. Requires the thread:read permission. Arguments: - customerId: ID! - externalId: ID!

threadByMSTeamsMessage

ChatGPT
Resolves a Microsoft Teams message to the Plain thread its conversation is on. If the message's thread was closed and the conversation continued in a successor thread, returns the open successor; if there is no open successor, returns the closed thread, which has lockedAt set. Returns null if Plain has not ingested the message. For a channel post, pass the root post's ID. While a thread is being created asynchronously, poll this query until it returns a thread whose lockedAt is null. While the first thread is being created it returns null; while a successor to a closed thread is being created it returns the closed thread. Requires the thread:read permission. Arguments: - msTeamsMessageId: ID! — The Teams message ID, as provided by Teams in the activity's id.

threadByRef

ChatGPT
Fetch a thread by its human-readable ref (e.g. T-1234). Useful when the ref is more convenient to store than the internal ID. Returns null if no match. Requires the thread:read permission. Arguments: - ref: String!

threadBySlackMessage

ChatGPT
Resolves a Slack message to the Plain thread it belongs to, using its Slack channel ID and message timestamp. Returns null if no thread is associated with the given Slack message. Requires the thread:read permission. Arguments: - slackChannelId: String! — The Slack channel the message is in, as provided by Slack (e.g. C0123ABCD). - slackMessageTimestamp: String! — The Slack ts of the message.

threadCluster

ChatGPT
Fetches a single thread cluster by its ID. Returns null if no cluster with that ID exists in the current workspace. This API is in beta and may change without notice. Arguments: - id: ID!

threadClusters

ChatGPT
Returns all AI-generated thread clusters for the current workspace, sorted by thread count descending. Clusters group semantically similar threads together so you can spot trends and recurring issues at a glance. The optional variant argument selects which clustering model run to return; omit it to receive the default variant. This API is in beta and may change without notice. Arguments: - variant: String

threadClustersPaginated

ChatGPT
Returns a paginated list of AI-generated thread clusters for the current workspace. Use filters to narrow results by company, tenant, or clustering variant. Supports standard cursor-based pagination via first/after and last/before. Requires the thread:read permission. This API is in beta and may change without notice. Cursor pagination supports first and after; a page size of 50 limits response size. Arguments: - first: Int - after: String - last: Int - before: String - filters: ThreadClustersFilter

threadDiscussion

ChatGPT
Fetch a single discussion by its ID. Returns null if no discussion with the given ID exists. Arguments: - threadDiscussionId: ID!

threadFieldSchema

ChatGPT
Fetches a single thread field schema by its ID. Returns null if no schema with the given ID exists. Selecting the createdBy/updatedBy actor down to its user additionally requires the user:read permission. Arguments: - threadFieldSchemaId: ID!

threadHeatmapMetric

ChatGPT
Fetch a heatmap metric for threads with filter support, distributing thread activity across a 7-day × 24-hour grid. Unlike the legacy heatmapMetric, this query uses the unified ThreadMetricFilters input for consistent filtering by label, tier, assignee, and more. Requires metrics:read; filtering assignedToUser to anyone other than the caller additionally requires metricsAgent:read. Arguments: - input: ThreadHeatmapMetricInput!

threadLinkGroups

ChatGPT
Returns a paginated list of thread link groups, each representing a distinct external entity (e.g. a Linear issue or Jira ticket) that is linked to one or more threads. Use this to build views that aggregate threads by a shared linked issue. Supports filtering by status, specific group IDs, company, or tier. Cursor pagination supports first and after; a page size of 50 limits response size. Arguments: - first: Int - after: String - last: Int - before: String - filters: ThreadLinkGroupFilter

threadMetricCapabilities

ChatGPT
Lists, for every thread metric, its default machineUsers mode, the modes it supports and what counts as machine-user activity. Requires metrics:read.

threadSingleValueMetric

ChatGPT
Fetch an aggregate (single-value) metric for threads with rich filter and group-by support. Returns one value per group bucket for the specified date range and SingleValueMetricName, making it suitable for summary dashboards or leaderboard-style breakdowns by assignee, tier, or label type. threads_csat__* metrics require filters.surveyResponse.rating (an integer from 1 to 3). Requires metrics:read; grouping by assignee or filtering assignedToUser to anyone other than the caller additionally requires metricsAgent:read. Arguments: - input: ThreadSingleValueMetricInput!

threadSlackUser

ChatGPT
Returns a Slack user associated with the given thread, looked up by their Slack user ID. Returns null if the user is not found in that thread's Slack context. Arguments: - threadId: ID! - slackUserId: ID!

threadTimeSeriesMetric

ChatGPT
Fetch a time-series metric for threads with rich filter and group-by support. Choose a TimeSeriesMetricName (e.g. threads_created_count, threads_first_response_time), specify a mandatory date range and bucketing interval, and optionally group results by assignee, company, tier, label type, and more. This is the preferred reporting query when you need server-side filtering across thread attributes. CSAT metrics require filters.surveyResponse.rating (an integer from 1 to 3). Requires metrics:read; grouping by assignee or filtering assignedToUser to anyone other than the caller additionally requires metricsAgent:read. Arguments: - input: ThreadTimeSeriesMetricInput!

threadsByExternalId

ChatGPT
Fetch all threads that share the given external ID, returned as a paginated connection. This is not scoped to a customer: because externalId is only unique per-customer, the same external ID can appear on threads belonging to different customers, and this query returns all of them. Returns an empty connection if there are no matches. Requires the thread:read permission. Cursor pagination supports first and after; a page size of 50 limits response size. Arguments: - externalId: ID! - first: Int - after: String - last: Int - before: String

tier

ChatGPT
Returns a single tier by its Plain ID. Returns null if no tier with that ID exists. Requires the tier:read permission. Deleting a tier is done by the user in the Plain app. The Plain app page is https://app.plain.com/workspace/w_…/settings/tiers/<tierId>. Arguments: - tierId: ID!

tiers

ChatGPT
Returns all tiers in the workspace, sorted by creation date. Supports cursor-based pagination. Requires the tier:read permission. Deleting a tier is done by the user in the Plain app. The Plain app page is https://app.plain.com/workspace/w_…/settings/tiers/<tierId>. Cursor pagination supports first and after; a page size of 50 limits response size. Arguments: - first: Int - after: String - last: Int - before: String

timelineEntries

ChatGPT
Returns a paginated list of all timeline entries for a customer, ordered from oldest to newest. Timeline entries include every event, message, note, and automated activity that has occurred across all of the customer's threads. Supports cursor-based pagination via first/after and last/before arguments.

timelineEntry

ChatGPT
Fetches a single timeline entry by its ID within a customer's timeline. Returns null if the entry does not exist.

toggleSlackMessageReaction

ChatGPT
Adds or removes a reaction from a slack message timeline entry. Arguments: - input: ToggleSlackMessageReactionInput!

triggerWorkflow

ChatGPT
Manually trigger a workflow against a specific thread. Returns the resulting WorkflowExecution so you can track the run's status and step results. Arguments: - input: TriggerWorkflowInput!

unarchiveLabelType

ChatGPT
Restores an archived label type so it can be applied to threads again. Requires the labelType:edit permission. Arguments: - input: UnarchiveLabelTypeInput!

unarchiveServiceLevelAgreementPolicy

ChatGPT
Restore an archived SLA policy so it can be assigned to threads again. Requires the serviceLevelAgreement:edit permission. Arguments: - input: UnarchiveServiceLevelAgreementPolicyInput!

unassignThread

ChatGPT
Remove the primary assignee from a thread, leaving it unassigned. Requires the thread:unassign and thread:read permissions. Arguments: - input: UnassignThreadInput!

unmarkCustomerAsSpam

ChatGPT
Clears the spam flag from a customer, restoring their threads to the inbox and metrics. The markedAsSpamAt timestamp is cleared. Requires the customer:edit permission. Arguments: - input: UnmarkCustomerAsSpamInput!

unsubscribeBroadcastRecipient

ChatGPT
Records that a broadcast recipient should not receive further broadcasts. Idempotent. Requires the broadcast:edit permission and the broadcasts feature flag. Arguments: - input: UnsubscribeBroadcastRecipientInput!

updateAccountTier

ChatGPT
Sets the tier for a single account, identified by its Plain ID or external ID. Pass a null tierIdentifier to remove the account from its current tier. Requires the tierMembership:read and tierMembership:create permissions. Arguments: - input: UpdateAccountTierInput!

updateAiToneRules

ChatGPT
Updates up to 10 AI tone rules in a single call. Each update item must include the rule ID and at least one field to change (description or isEnabled). Enabling a rule that would push the total number of enabled rules above 7 returns an error. Returns the full updated rule objects. Requires the aiToneRule:edit permission. Arguments: - input: UpdateAiToneRulesInput!

updateBroadcast

ChatGPT
Updates one or more fields of an existing broadcast. Each field uses a wrapper input — pass { value: ... } to set it or omit it entirely to leave it unchanged. type is not updatable. Requires the broadcast:edit permission. Arguments: - input: UpdateBroadcastInput!

updateBroadcastAudience

ChatGPT
Updates a broadcast audience's name, filters, or both. Editing an audience changes who every broadcast using it will reach on its next send. Requires the broadcastAudience:edit permission. Arguments: - input: UpdateBroadcastAudienceInput!

updateBusinessHoursOverride

ChatGPT
Update an override's name, dates or slots. Omitted fields are left unchanged. Requires the businessHours:edit permission. Arguments: - input: UpdateBusinessHoursOverrideInput!

updateBusinessHoursSchedule

ChatGPT
Update a business hours schedule's name, its slots, or both. Omitted fields are left unchanged; passing an empty slots array clears the schedule's business hours. Overlapping and adjacent slots are merged on write. Requires the businessHours:edit permission. Arguments: - input: UpdateBusinessHoursScheduleInput!

updateChatApp

ChatGPT
Update the name or logo of an existing chat app. Only the fields provided in the input are changed. Requires the chatApp:edit permission. Arguments: - input: UpdateChatAppInput!

updateConnectedDiscordChannel

ChatGPT
Updates settings for a connected Discord channel, such as enabling or disabling it. Disabled channels will not receive new messages from Plain. Arguments: - input: UpdateConnectedDiscordChannelInput!

updateConnectedSlackChannel

ChatGPT
Updates the settings of a connected Slack channel, such as its channel type (customer or discussion) or whether it is enabled. Arguments: - input: UpdateConnectedSlackChannelInput!

updateCustomerCardConfig

ChatGPT
Partially updates a customer card config. Only fields that are provided in the input will be changed; omitted fields are left unchanged. Updating apiUrl or apiHeaders requires the customerCardConfigApiDetails:edit permission. Changing the key must still result in a unique key within the workspace. Arguments: - input: UpdateCustomerCardConfigInput!

updateCustomerSurvey

ChatGPT
Updates an existing customer survey. At least one field must be provided. Partial updates are supported — only the fields you include are changed. Requires the customerSurvey:edit permission. Arguments: - input: UpdateCustomerSurveyInput!

updateDashboard

ChatGPT
Updates metadata and, when widgets is provided, replaces the dashboard's full widget set in one transaction. Requires dashboard:edit. Arguments: - input: UpdateDashboardInput!

updateEscalationPath

ChatGPT
Updates an existing escalation path. All fields are optional — only the fields provided will be changed. If steps is provided, it replaces the full list of steps; omit it to leave the current steps unchanged. Returns an error if the escalation path does not exist. Requires the escalationPath:edit permission. Arguments: - input: UpdateEscalationPathInput!

updateGeneratedReply

ChatGPT
Record teammate feedback (thumbs up / thumbs down and an optional comment) on a generated reply. Use this to signal whether a suggestion was helpful so Plain can improve future suggestions. Requires the generatedReply:edit permission. Arguments: - input: UpdateGeneratedReplyInput!

updateHelpCenter

ChatGPT
Update a help center's names, description, colour, logo or whether chat is on. Only the arguments you pass are changed. Requires the helpCenter:edit permission. Pass each field as its own argument, not wrapped in an input object. Custom JavaScript, sign-in, access, the type and the subdomain can't be changed here, because they run code on every public page, take a secret, or change who can see the help center and where. The user changes them in the Plain app: the page is https://app.plain.com/workspace/w_…/help-center/<helpCenterId>.

updateHelpCenterArticleGroup

ChatGPT
Update the name of an existing article group. Requires the helpCenter:edit permission. Arguments: - input: UpdateHelpCenterArticleGroupInput!

updateHelpCenterIndex

ChatGPT
Replace the navigation index (sidebar order and hierarchy) of a help center in a single call. The input requires the current navigation index hash. A stale hash fails the update because the index changed since that snapshot. Requires the helpCenter:edit permission. Arguments: - input: UpdateHelpCenterIndexInput!

updateImportJobDefinition

ChatGPT
Disable the active import job definition for a service integration. This is the only supported update — pass isEnabled: false to stop future sync runs. Returns an error if no enabled definition exists for the given service. Arguments: - input: UpdateImportJobDefinitionInput!

updateInternalNotifications

ChatGPT
Marks one or more internal notifications as read, unread, or archived. Pass the notification IDs to update along with the desired readAt and/or archivedAt timestamps. Set readAt to null to mark a notification as unread; set archivedAt to a timestamp to archive it. Returns the updated notifications. Requires the user:read permission. Arguments: - input: UpdateInternalNotificationsInput!

updateLabelType

ChatGPT
Updates properties of an existing label type. Uses field-level wrapper inputs: pass { value: ... } to change a field, or omit the field entirely to leave it unchanged. At least one field besides labelTypeId must be provided. Requires the labelType:edit permission. Arguments: - input: UpdateLabelTypeInput!

updateMachineUser

ChatGPT
Updates the name, description, or avatar of an existing machine user. At least one of fullName, publicName, description, or avatar must be provided. Requires the machineUser:edit permission. Arguments: - input: UpdateMachineUserInput!

updateMyUser

ChatGPT
Updates profile fields (display name, short name, or avatar) for the currently authenticated human user. Only the fields provided are changed; omitted fields are left unchanged. Not available to machine users. Arguments: - input: UpdateMyUserInput!

updateNote

ChatGPT
Updates the text, markdown, or attachments of an existing note. Requires the note:edit permission. Arguments: - input: UpdateNoteInput!

updateSavedThreadsView

ChatGPT
Updates an existing saved threads view. All fields in the input are optional; only the fields you provide will be changed. Depending on workspace settings, only the view's creator or workspace admins may be allowed to edit a view they did not create. Arguments: - input: UpdateSavedThreadsViewInput!

updateServiceLevelAgreement

ChatGPT
Update an existing SLA's time target, priority or label filter, business-hours setting, or breach actions. An SLA belongs to a tier or to an SLA policy. The SLA's ID alone identifies the update target. You cannot change an SLA's type after creation. Use the field-level wrapper inputs (e.g. { "value": 60 }) for the fields you want to change and omit the rest. Requires the serviceLevelAgreement:edit permission. Arguments: - input: UpdateServiceLevelAgreementInput!

updateServiceLevelAgreementPolicy

ChatGPT
Update an SLA policy and its targets. Pass the full set of targets you want the policy to have: a target of an existing type is updated in place, so live SLA trackers are unaffected, a new type is added, and a type you leave out is removed along with its trackers. Requires the serviceLevelAgreement:edit permission. Arguments: - input: UpdateServiceLevelAgreementPolicyInput!

updateSetting

ChatGPT
Create or overwrite a named setting at the given scope. Provide exactly one value field in SettingValueInput (boolean, string, number, or stringArray) that matches the expected type for the setting code. Returns the stored setting on success. Arguments: - input: UpdateSettingInput!

updateSidekickCustomSkill

ChatGPT
Update a workspace custom skill. Only the provided fields are changed. Arguments: - input: UpdateSidekickCustomSkillInput!

updateSnippet

ChatGPT
Updates one or more fields of an existing snippet. Each field uses a wrapper input — pass { value: "..." } to set it or omit it entirely to leave it unchanged. To remove the snippet's path (un-group it) pass { value: null }. Requires the snippet:edit permission. Arguments: - input: UpdateSnippetInput!

updateTask

ChatGPT
Update an existing task. Only the fields you include are changed — omitted fields are left as-is. Setting companyId clears any existing tenantId and vice versa, since a task may be linked to at most one. Requires the task:edit permission. Arguments: - input: UpdateTaskInput!

updateTenantTier

ChatGPT
Sets the tier for a single tenant, identified by its Plain ID or external ID. Pass a null tierIdentifier to remove the tenant from its current tier. Requires the tierMembership:read and tierMembership:create permissions. Deprecated. Arguments: - input: UpdateTenantTierInput!

updateThreadAccount

ChatGPT
Move a thread to a different account, or pass accountIdentifier: null to detach it from its current account. Requires the thread:edit permission. Arguments: - input: UpdateThreadAccountInput!

updateThreadAgentStatus

ChatGPT
Update the AI agent status of a thread (IN_PROGRESS, HANDED_OFF, or HANDLED). Use this to signal that an AI agent has taken over, handed off to a human, or fully resolved the thread. Requires the thread:edit permission. Arguments: - input: UpdateThreadAgentStatusInput!

updateThreadChannelAssociationAccountMembershipPolicy

ChatGPT
Changes how accounts are assigned for an existing thread channel association. Requires the threadChannelAssociation:edit permission. Arguments: - input: UpdateThreadChannelAssociationAccountMembershipPolicyInput!

updateThreadChannelAssociationTenantMembershipPolicy

ChatGPT
Changes how tenants are assigned for an existing thread channel association. Requires the threadChannelAssociation:edit permission. Deprecated. Arguments: - input: UpdateThreadChannelAssociationTenantMembershipPolicyInput!

updateThreadEscalationPath

ChatGPT
Attach a thread to a specific escalation path, or pass escalationPathId: null to detach it. An escalation path defines the sequence of users or teams the thread escalates through if nobody responds in time. Requires the thread:edit permission. Arguments: - input: UpdateThreadEscalationPathInput!

updateThreadExternalId

ChatGPT
Update the external ID of a thread. Pass externalId: null to clear it. Requires the thread:edit permission. Arguments: - input: UpdateThreadExternalIdInput!

updateThreadFieldSchema

ChatGPT
Updates an existing thread field schema. All fields except key and type are mutable. String fields use wrapper inputs (e.g. { value: "..." }) to distinguish a deliberate null from an omitted value. Requires the threadFieldSchema:edit permission. Arguments: - input: UpdateThreadFieldSchemaInput!

updateThreadServiceLevelAgreementPolicy

ChatGPT
Assign an SLA policy to a thread. A policy takes precedence over the thread's tier when selecting SLAs. Pass serviceLevelAgreementPolicyId: null to detach the policy and fall back to the tier's SLAs. Requires the thread:edit permission. Arguments: - input: UpdateThreadServiceLevelAgreementPolicyInput!

updateThreadSuggestedActionStatus

ChatGPT
Accept or dismiss a specific AI-suggested action on a thread's catchup summary. Pass the suggestedActionId from the thread's catchupDetail and the new status. Requires the thread:edit permission. Arguments: - input: UpdateThreadSuggestedActionStatusInput!

updateThreadTenant

ChatGPT
Move a thread to a different tenant, or pass tenantIdentifier: null to detach it from its current tenant. Requires the thread:edit permission. Deprecated. Arguments: - input: UpdateThreadTenantInput!

updateThreadTier

ChatGPT
Assign a thread to a tier, which governs the SLAs applied to it. Pass tierIdentifier: null to detach the thread from its current tier. Requires the thread:edit permission. Arguments: - input: UpdateThreadTierInput!

updateThreadTitle

ChatGPT
Update the title of a thread. Requires the thread:edit permission. Arguments: - input: UpdateThreadTitleInput!

updateTier

ChatGPT
Updates the name, color, external ID, default priority, or default flag of an existing tier. Only the fields you provide are changed. Requires the tier:update permission. Arguments: - input: UpdateTierInput!

updateUserDefaultSavedThreadsView

ChatGPT
Sets or clears the default saved threads view for a specific user. Pass null for savedViewId to remove the default. This controls which thread view the user sees when they first open the inbox. Arguments: - input: UpdateUserDefaultSavedThreadsViewInput!

updateWorkflow

ChatGPT
Update a workflow's name, trigger configuration, entry step, or published status. Arguments: - input: UpdateWorkflowInput!

updateWorkflowStep

ChatGPT
Update a single workflow step's configuration, transitions, or canvas position. Replacing transitions is a full replacement of the array. Arguments: - input: UpdateWorkflowStepInput!

upsertAccount

ChatGPT
Creates a new account or updates an existing one identified by externalId or accountId. Use this to keep Plain's account records in sync with the groups or organisations in your own product. The result field on the output indicates whether a record was created or updated. Requires the tenant:create and tenant:edit permissions. Arguments: - input: UpsertAccountInput!

upsertAccountField

ChatGPT
Sets or updates a field value for a specific account. Identify the target field using accountFieldIdentifier (account ID + external field ID) and pass exactly one value argument matching the schema's type (e.g. stringValue, numberValue, booleanValue, arrayValue, dateValue, userReferenceValues, or accountReferenceValues). Requires the tenantField:create, tenantField:update, and tenantFieldSchema:read permissions. Identifying the account by externalId also requires the tenant:read permission. Arguments: - input: UpsertAccountFieldInput!

upsertAccountFieldSchema

ChatGPT
Creates or updates one or more account field schemas in a single call. Each schema is identified by the combination of source and externalFieldId — if a schema with that pair already exists it is updated, otherwise a new one is created. Requires the tenantFieldSchema:create, tenantFieldSchema:update, and tenantFieldSchema:delete permissions. Arguments: - input: UpsertAccountFieldSchemaInput!

upsertCustomer

ChatGPT
Creates or updates a customer identified by email address, external ID, or Plain customer ID. Supply onCreate fields for values to set when creating and onUpdate fields for values to apply when the customer already exists. The output's result field indicates whether the customer was CREATED, UPDATED, or NOOP (existed and no values changed). Requires the customer:create and customer:edit permissions. Arguments: - input: UpsertCustomerInput!

upsertHelpCenterArticle

ChatGPT
Create or update a help center article. Omit helpCenterArticleId to create a new article; provide it to update an existing one. The slug is normalized to lowercase and must be unique within the help center. contentHtml is rendered directly in the help center. status (DRAFT or PUBLISHED) and description must always be sent; description may be null. Requires the helpCenter:edit permission. Arguments: - input: UpsertHelpCenterArticleInput!

upsertMyEmailSignature

ChatGPT
Creates or updates the email signature for the currently authenticated user. The signature is appended automatically to outbound emails sent by that user. Arguments: - input: UpsertMyEmailSignatureInput!

upsertTeamSettings

ChatGPT
Create or update the settings for a team (label type of kind TEAM). If settings do not yet exist for the given team, they are created with defaults (round-robin disabled, max capacity 5); otherwise the existing settings are updated with the supplied values. The labelTypeId must refer to a label type of type TEAM — passing any other label type ID returns a validation error. Requires the labelType:edit permission. Arguments: - input: UpsertTeamSettingsInput!

upsertTenant

ChatGPT
Creates a new tenant or updates an existing one identified by externalId or tenantId. Use this to keep Plain's tenant records in sync with the groups or organisations in your own product. The result field on the output indicates whether a record was created or updated. Requires the tenant:read and tenant:create permissions. Deprecated. Arguments: - input: UpsertTenantInput!

upsertTenantField

ChatGPT
Sets or updates a field value for a specific tenant. Identify the target field using tenantFieldIdentifier: the tenant plus the field's externalFieldId, which is the field's key (such as contract_value). Pass the field's type and the one value argument for it: STRING_TYPE uses stringValue, NUMBER_TYPE numberValue, BOOLEAN_TYPE booleanValue, STRING_ARRAY arrayValue, DATETIME_TYPE dateValue, USER_REFERENCE_TYPE userReferenceValues and TENANT_REFERENCE_TYPE tenantReferenceValues. Requires tenant:edit permission. Deprecated. Arguments: - input: UpsertTenantFieldInput!

upsertTenantFieldSchema

ChatGPT
Creates or updates one or more tenant field schemas in a single call. Each schema is identified by the combination of source and externalFieldId — if a schema with that pair already exists it is updated, otherwise a new one is created. Requires tenantFieldSchema:create or tenantFieldSchema:edit permission. Deprecated. Arguments: - input: UpsertTenantFieldSchemaInput!

upsertThreadField

ChatGPT
Sets (or updates) a single thread field value on a thread, identified by thread ID and field key. Creates the field if it does not exist, or overwrites the existing value if it does. Requires the threadField:create and threadField:update permissions. Arguments: - input: UpsertThreadFieldInput!

user

ChatGPT
Fetch a single workspace member by their ID. Returns null if no user with that ID exists. Requires the user:read permission. Changing a member's role is done by the user in the Plain app. The Plain app page is https://app.plain.com/workspace/w_…/settings/members/<userId>. Arguments: - userId: ID!

userAuthDiscordChannelIntegration

ChatGPT
Returns the current user's personal Discord authentication for a specific guild, or null if the user has not connected their Discord account to that guild. Arguments: - discordGuildId: String!

userAuthDiscordChannelIntegrations

ChatGPT
Returns a paginated list of all personal Discord authentication integrations for the current user across all guilds. Cursor pagination supports first and after; a page size of 50 limits response size. Arguments: - first: Int - after: String - last: Int - before: String

userAuthSlackIntegration

ChatGPT
Returns the current user's user-auth Slack integration for the given Slack workspace, or null if not connected. Used for integrations that send messages as the user rather than as a bot. Arguments: - slackTeamId: String!

userAuthSlackIntegrationByThreadId

ChatGPT
Returns the current user's user-auth Slack integration for the Slack workspace associated with the given thread, or null if not connected. Arguments: - threadId: ID!

userByEmail

ChatGPT
Fetch a workspace member by their email address. Returns null if no match is found. Deleted users are also returned — check the isDeleted, deletedAt, and deletedBy fields to determine whether the user has been removed. Requires the user:read permission. Arguments: - email: String!

userSlackChannelMemberships

ChatGPT
Returns the Slack channels the current user belongs to within the given Slack workspace. Useful for populating channel pickers in UI integrations. Arguments: - slackTeamId: String!

users

ChatGPT
List all human members of the workspace, with optional filters to narrow results by role assignability. Supports cursor-based pagination. Requires the user:read permission. Inviting people and changing their roles are done by the user in the Plain app. The Plain app page is https://app.plain.com/workspace/w_…/settings/members/add, or …/settings/members/<userId> to change a member's role. Cursor pagination supports first and after; a page size of 50 limits response size. Arguments: - filters: UsersFilter - first: Int - after: String - last: Int - before: String

verifyHelpCenterCustomDomainName

ChatGPT
Trigger a DNS verification check for the custom domain configured on the help center. Returns an error if the expected TXT record is not yet visible. Requires the helpCenter:edit permission. Arguments: - input: VerifyHelpCenterCustomDomainNameInput!

webhookTarget

ChatGPT
Fetch a single webhook target by its ID. Returns null if no target with that ID exists in the workspace. Requires the webhookTarget:read permission. Creating, changing and deleting webhook targets are done by the user in the Plain app, because a webhook sends workspace events to an outside URL. The Plain app page is https://app.plain.com/workspace/w_…/settings/webhooks/<webhookTargetId>, or …/settings/webhooks/add for a new one. Arguments: - webhookTargetId: ID!

webhookTargets

ChatGPT
List all webhook targets registered in the workspace, paginated. Returns every endpoint Plain is configured to deliver events to. Requires the webhookTarget:read permission. Creating, changing and deleting webhook targets are done by the user in the Plain app, because a webhook sends workspace events to an outside URL. The Plain app page is https://app.plain.com/workspace/w_…/settings/webhooks/add, or …/settings/webhooks/<webhookTargetId> for an existing one. Cursor pagination supports first and after; a page size of 50 limits response size. Arguments: - first: Int - after: String - last: Int - before: String

webhookVersions

ChatGPT
List all available webhook schema versions. Use this to discover which versions you can pin a webhook target to, and to check whether a version you are already using has been deprecated. Requires the webhookTarget:read permission. Cursor pagination supports first and after; a page size of 50 limits response size. Arguments: - first: Int - after: String - last: Int - before: String

workflow

ChatGPT
Get a workflow by id. Returns null if no workflow with the given ID exists. Workflows are the step-based automation model that supports conditions, actions, and wait steps connected in a graph. Arguments: - workflowId: ID!

workflowBuilderGuide

ChatGPT
How to build or edit a workflow with these tools, as markdown: the trigger events, every condition and action payload with its fields, how steps connect, and how to publish and link to the result. Requires the workflowRule:read permission.

workflowCapabilities

ChatGPT
Returns which blocks (condition/action/wait steps) are available for a workflow of the given trigger type. The builder UI sources its palette from this so the allow-list lives in the backend, not hardcoded in the UI. E.g. SCHEDULE workflows have no thread, so they allow no conditions/waits and only a restricted set of action types. Arguments: - triggerType: WorkflowTriggerType!

workflowExecution

ChatGPT
Get a single workflow execution by id. Returns null if no execution with the given ID exists. Use this to inspect the status, timing, and per-step results of a specific run. Arguments: - workflowExecutionId: ID!

workflowExecutions

ChatGPT
List executions for a specific workflow, paginated. Use this to audit the run history of a workflow and check for failures. Cursor pagination supports first and after; a page size of 50 limits response size. Arguments: - workflowId: ID! - first: Int - after: String - last: Int - before: String

workflowExecutionsByEntity

ChatGPT
List workflow executions filtered by the entity they ran against (e.g. a specific thread), paginated. Useful for showing all automation that has fired on a given thread. Optionally narrow further by workflow ID or execution status. Cursor pagination supports first and after; a page size of 50 limits response size. Arguments: - filters: WorkflowExecutionByEntityFilter! - first: Int - after: String - last: Int - before: String

workflowExecutionsForWorkspace

ChatGPT
List executions across every workflow in the workspace, newest first, paginated. Use this for a workspace-wide view of what automation has been doing, or narrow it with filters — by workflow, by the entity a run fired against, or by state. Executions that have not started yet sort to the top. Cursor pagination supports first and after; a page size of 50 limits response size. Arguments: - filters: WorkflowExecutionsFilter - first: Int - after: String - last: Int - before: String

workflowTemplate

ChatGPT
Null if no template with that ID is published. Deprecated templates still resolve here, which is what keeps existing install links working. Needs an authenticated caller and nothing more. Arguments: - templateId: ID!

workflowTemplateGallery

ChatGPT
Published templates for the gallery, metadata only — deprecated ones are already absent because the templates repo omits them. Needs an authenticated caller and nothing more: templates are one published document, identical for every workspace, so there is nothing to scope by permission.

workflows

ChatGPT
List workflows in the workspace, paginated. Use filters to narrow results by trigger type (MANUAL, EVENTS or SCHEDULE), published status, the events an events trigger listens for, or the entities their steps reference (e.g. every workflow applying a given SLA policy). Ordered by position ascending unless sortBy says otherwise. Cursor pagination supports first and after; a page size of 50 limits response size. Arguments: - first: Int - after: String - last: Int - before: String - filters: WorkflowsFilter - sortBy: WorkflowsSort

workspace

ChatGPT
Fetch a workspace by its ID. Returns null if the workspace does not exist or the caller does not have access to it. Arguments: - workspaceId: ID!

workspaceChatSettings

ChatGPT
Returns the workspace-level chat settings, including whether the live-chat channel is enabled for this workspace.

workspaceDiscordChannelIntegration

ChatGPT
Fetches a single workspace Discord channel integration by its ID. Returns null if no integration with that ID exists. Not connected yet? Connecting needs the user's approval in the provider. The Plain app page is https://app.plain.com/workspace/w_…/install/discord. Arguments: - integrationId: ID!

workspaceDiscordChannelIntegrations

ChatGPT
Returns a paginated list of all Discord server (guild) channel integrations connected to this workspace. Not connected yet? Connecting needs the user's approval in the provider. The Plain app page is https://app.plain.com/workspace/w_…/install/discord. Cursor pagination supports first and after; a page size of 50 limits response size. Arguments: - first: Int - after: String - last: Int - before: String

workspaceEmailSettings

ChatGPT
Returns the workspace's email settings, including whether email is enabled, any custom domain configuration, and BCC addresses. Changing these settings, including the support email domain, its forwarding and alternate addresses, is done by the user in the Plain app, because they decide where mail is sent from and to. The Plain app page is https://app.plain.com/workspace/w_…/settings/email.

workspaceInvites

ChatGPT
Returns all pending invites for the current workspace. Use this to view outstanding invitations and their status from an admin perspective. Inviting someone is done by the user in the Plain app. The Plain app page is https://app.plain.com/workspace/w_…/settings/members/add. Cursor pagination supports first and after; a page size of 50 limits response size. Arguments: - first: Int - after: String - last: Int - before: String

workspaceMSTeamsIntegration

ChatGPT
Returns the workspace-level Microsoft Teams integration, or null if none has been created yet. Not connected yet? Connecting needs the user's approval in the provider. The Plain app page is https://app.plain.com/workspace/w_…/install/ms-teams.

workspaceSetup

ChatGPT
Returns how far this workspace has progressed through setup: channels, teammates, label types, tiers, automation and Sidekick Agent tools. These are the same steps as the Onboarding checklist the user sees in the Plain app. Connecting the email channel and inviting teammates are done by the user in the Plain app. The Plain app page is https://app.plain.com/workspace/w_…/settings/email or https://app.plain.com/workspace/w_…/settings/members/add.

workspaceSlackChannelIntegration

ChatGPT
Returns a single workspace Slack channel integration by ID, or null if not found. Not connected yet? Connecting needs the user's approval in the provider. The Plain app page is https://app.plain.com/workspace/w_…/install/slack. Arguments: - integrationId: ID!

workspaceSlackChannelIntegrations

ChatGPT
Returns a paginated list of all workspace Slack channel integrations for this workspace. Not connected yet? Connecting needs the user's approval in the provider. The Plain app page is https://app.plain.com/workspace/w_…/install/slack. Cursor pagination supports first and after; a page size of 50 limits response size. Arguments: - first: Int - after: String - last: Int - before: String

workspaceSlackIntegration

ChatGPT
Returns a single workspace-level Slack notifications integration by ID, or null if not found. A Slack channel integration's ID returns null here because channel and notification integrations have separate records. Not connected yet? Connecting needs the user's approval in the provider. The Plain app page is https://app.plain.com/workspace/w_…/settings/slack. Arguments: - integrationId: ID!

workspaceSlackIntegrations

ChatGPT
Returns a paginated list of all workspace-level Slack notifications integrations for this workspace. Slack support-channel integrations have separate records from notification integrations. Not connected yet? Connecting needs the user's approval in the provider. The Plain app page is https://app.plain.com/workspace/w_…/settings/slack. Cursor pagination supports first and after; a page size of 50 limits response size. Arguments: - first: Int - after: String - last: Int - before: String

workspaceSlackSidekickIntegration

ChatGPT
Returns the current workspace's Slack Sidekick Agent integration, or null if Sidekick Agent has not been installed. Requires the workspaceSlackSidekickIntegration:read permission. Not connected yet? Connecting needs the user's approval in the provider. The Plain app page is https://app.plain.com/workspace/w_…/settings/slack.

Capabilities

Writes

Example Prompts

Click any prompt to copy it.

Similar Apps

Listed on MCP App Store

Listed on MCP App Store

Add this badge to your site or README. It links to this page.

HTML

<a href="https://mcp-app-store.keenethics-labs.com/app/plain"><img src="https://mcp-app-store.keenethics-labs.com/badges/listed-on-mcp-app-store.svg" alt="Listed on MCP App Store" width="220" height="44"></a>

Markdown

[![Listed on MCP App Store](https://mcp-app-store.keenethics-labs.com/badges/listed-on-mcp-app-store.svg)](https://mcp-app-store.keenethics-labs.com/app/plain)