type.com

npx add-mcp 'https://api.type.com/mcp'

Type MCP lets supported AI clients work with your Type workspace through a hosted, OAuth-protected Model Context Protocol server. It does not require the Type CLI, a local process, or an API key.

Through Type MCP a client can read your workspace, manage Spaces and Channels, create and update documents and skills, build and publish Type Apps, run automations, and call your connected integrations. Every request runs as the signed-in Type user in the organization selected during sign-in, with the same permissions as Type’s web app and CLI.

Install Type MCP

For Claude, open the one-click installer:

Connect Type to Claude

Claude will ask you to review the connector, sign in to Type, select an organization, and approve the connection.

For ChatGPT, open the ChatGPT installer:

Connect Type to ChatGPT

Sign in to Type, then follow the on-page steps: turn on Developer mode under ChatGPT’s Security and login settings, open Plugins, add a connection named Type with the server URL shown on the page, choose OAuth, and approve Type access. Developer-mode availability depends on your ChatGPT account and workspace policy.

To configure another supported MCP client manually, use this server URL:

https://api.type.com/mcp

The client must support remote Streamable HTTP MCP servers and OAuth. The server accepts only POST requests on that URL and publishes its OAuth metadata at /.well-known/oauth-protected-resource/mcp.

Type MCP publishes server instructions during initialization. Clients that honor MCP server instructions show them to the model as standing guidance to build automations, apps, integrations, and skills in Type rather than as local scripts, cron jobs, or ad-hoc API clients, and to start with type_whoami to confirm the signed-in user and organization. If you also use the Type CLI, its installer adds the same guidance to your Claude Code and Codex global instruction files.

Available actions

Type MCP tools are grouped by prefix. Read tools are annotated read-only; every other tool is a write action that your MCP client should ask you to approve.

Area	Tools	What they do
Identity	type_auth_status, type_whoami, type_orgs_list	Confirm authentication, show the signed-in user and selected organization, and list your organization memberships.
Spaces	type_spaces_list, type_spaces_get, type_spaces_create, type_spaces_update, type_spaces_archive, type_spaces_merge, type_spaces_members, type_spaces_add_member, type_spaces_remove_member, type_spaces_join, type_spaces_leave, type_spaces_set_autoreply	Discover and manage Spaces, membership, and autoreply.
Channels	type_channels_list, type_channels_create, type_channels_update, type_channels_archive, type_channels_merge, type_channels_set_autoreply	Discover and manage Channels inside a Space.
Search and threads	type_search_workspace, type_threads_recent, type_threads_list, type_thread_get, type_threads_batch, type_thread_reply	Search workspace-native messages, threads, Spaces, people, files, docs, and apps; list and read threads; reply in a thread and mention teammates.
Documents	type_documents_list, type_documents_pull, type_documents_push	List, read, create, and update Markdown documents, including public links.
Skills	type_skills_list, type_skills_inspect, type_skills_push, type_skills_sync	List, inspect, create, and update skill packages for the organization or a Space.
Apps	type_apps_list, type_apps_resolve, type_apps_scaffold, type_apps_checkout, type_apps_save_source, type_apps_deploy_development, type_apps_prepare, type_apps_publish_first, type_apps_get_publish_approval, type_apps_publish, type_apps_get_build, type_apps_logs, type_apps_resolve_session, type_apps_get_access, type_apps_set_access, type_apps_share	Build, preview, publish, and share Type Apps without a local checkout.
Automations	type_scheduled_actions_list, type_scheduled_actions_get, type_scheduled_actions_create, type_scheduled_actions_update, type_scheduled_actions_delete, type_synced_events_list, type_synced_events_get, type_synced_events_create, type_synced_events_update, type_synced_events_set_enabled, type_synced_events_delete, type_synced_events_poll, type_synced_events_send, type_automations_test, type_automations_status, type_automations_history, type_slack_channels	Create, test, and inspect scheduled actions and synced events.
Integrations	type_integrations_available, type_integrations_connections, type_integrations_list, type_integrations_tools, type_integrations_call, type_integrations_connect, type_integrations_connection_status, type_integrations_create, type_integrations_disconnect, type_integrations_save_custom_api, type_integrations_verify, type_integrations_request, type_integrations_permissions, type_integrations_set_grant, type_integrations_set_personal_mode, type_integrations_delete_grant	Discover, connect, call, and manage permissions for connected services and Custom APIs.

Type MCP can reply in an existing thread with type_thread_reply, but it does not create new threads or read file attachments beyond search results. Use Type itself, type-cli threads create to start a new agent task, or type-cli sessions push to import a local transcript.

Tool responses are JSON. A failed call returns isError: true with { "ok": false, "error": { "code", "message" } }, where code is invalid_input, not_found, forbidden, conflict, or unexpected_error. Input schemas are strict: unknown fields are rejected, so use the current schemas your client discovers rather than guessing field names.

Spaces, Channels, and stable IDs

Use type_spaces_list to list the Spaces visible to you. It exposes regular product Spaces, not alert feeds, direct-message containers, archived Spaces, or dedicated Sidekick Spaces. Each result includes a stable Space id, its visibility, and an isMember value. Pass the exact ID as spaceId to the thread and skill tools; do not derive an ID from a Space name, slug, or URL.

The list can include a public Space with isMember: false. You may read that public Space’s threads, but member-only operations remain unavailable. Use type_channels_list only with the ID of a Space where isMember: true to list its Channels. Each result includes its stable Channel id, owning spaceId, name, slug, isDefault state, autoreply setting, and connected sources. A Channel ID is only valid with its owning Space ID.

Every Space has a default destination shown as Threads. type_channels_list returns it with name: "Threads" and isDefault: true while preserving its stable ID and persisted slug. Use isDefault, not the name or slug, to identify it.

Tool	Required input	Result
type_spaces_list	None	Visible regular Spaces, stable IDs, and membership state.
type_channels_list	Member Space spaceId	Active Channels in that Space, including Threads.

Manage Spaces and Channels

The management tools take space and channel references instead of spaceId and channelId. A reference can be a stable ID, a slug, or an exact name; ambiguous names are rejected, so prefer IDs from discovery.

• type_spaces_create takes name, an optional description, and visibility (public by default, or private). type_spaces_update changes any of those on an existing Space.
• type_spaces_members, type_spaces_add_member, and type_spaces_remove_member manage membership; member accepts an email, user ID, or exact display name. type_spaces_join and type_spaces_leave act on the signed-in user.
• type_spaces_set_autoreply and type_channels_set_autoreply take an explicit enabled boolean. Space autoreply controls webhook replies and the default for new threads; Channel autoreply controls replies to new threads in that Channel.
• type_channels_create and type_channels_update take space plus name and an optional description.
• type_spaces_archive and type_channels_archive hide a Space or Channel. type_spaces_merge takes source, target, and a nullable threadsChannelName; type_channels_merge takes space, source, and target. Merges move content into the target and archive the source, and are destructive. Space merges require an organization admin, and the default Threads destination cannot be archived or merged.

These tools apply the same permission checks as the Type CLI and always act as the authenticated user in the selected organization; they never accept an actor or organization override.

Find and read threads

For workspace retrieval, start with type_search_workspace when the user supplied a topic. Use type_threads_recent for newest or recently active thread questions without a query; its default is creation-time order. Then call type_threads_batch for several candidate thread IDs or type_thread_get for one.

type_search_workspace takes a query of 1–200 characters, an optional types list (messages, threads, spaces, users, files, docs, apps), and an optional per-type limit of up to 50. Narrow types when the target kind is known.

type_threads_list uses a flat Space-scoped input. It requires spaceId and accepts an optional channelId, plus optional from / to ISO timestamps, status (open, closed, or all), limit, and cursor:

{ "spaceId": "space-id", "channelId": "channel-id" }

type_threads_recent uses an optional nested scope. Omit scope for recent threads across the organization. Pass only spaceId for every Channel in one Space, or include that Space’s channelId to narrow the result. It also accepts status, sort (created or activity), limit, and cursor:

{ "scope": { "spaceId": "space-id" } }

{ "scope": { "spaceId": "space-id", "channelId": "channel-id" } }

type_threads_recent does not accept top-level spaceId or channelId. The nested shape ensures that a Channel is always paired with its owning Space.

For either tool, omitting channelId means all threads in the selected scope, not only Threads. To select only the default Threads destination, pass the stable ID of the isDefault: true item returned by type_channels_list. List tools return 20 threads by default and at most 50 per page.

type_thread_get returns 50 messages per page by default (at most 500) within a text budget that defaults to 12,000 characters (maxTextChars, at most 48,000). type_threads_batch reads up to 10 threads with a shared budget that defaults to 24,000 characters (maxTotalChars, at most 48,000) and 25 messages per thread (perThreadLimit, at most 50). If any requested thread is not readable, the whole batch fails.

Thread reads follow Space visibility. You may list or read threads in a public Space even when its type_spaces_list result has isMember: false. Private Space threads remain available only to members.

Reply in a thread

type_thread_reply posts a reply into an existing thread as the signed-in user. It takes the threadId (the stable thread ID returned by search and thread tools), the reply content as plain text, and an optional replyMode:

{
  "threadId": "thread_123",
  "content": "@Fletcher Richman can you review this? cc <@user_01…>",
  "replyMode": "chat"
}

Mention a teammate by writing @Display Name (case-insensitive, matched against organization members) or <@user_id> (exact; find IDs with type_search_workspace and the users type). Resolved mentions render as mention chips and notify that person. #space-name links a Space. The result includes the message and thread URLs, mentions (who was resolved and notified), and unresolvedMentions (tokens that matched nobody). An entry in unresolvedMentions means nobody was notified for that name, so look the person up and retry with <@user_id> when the mention matters.

A reply is either a Team message (replyMode: "chat"), which never starts or resumes an AI response, or an AI prompt (replyMode: "prompt"), which asks the thread’s agent to respond. When replyMode is omitted, a reply that resolved a user mention is sent as a Team message and any other reply is sent as an AI prompt, so a message addressed to a teammate does not also wake the agent. Replying requires access to the thread’s Space, closed threads reject replies, and direct-message threads are not supported.

Thread results and location-bearing search results use a normalized location:

{
  "location": {
    "space": { "id": "space-id", "name": "Product", "slug": "product" },
    "placement": { "type": "threads" }
  }
}

Named Channel placement includes the Channel’s stable identity:

{
  "location": {
    "space": { "id": "space-id", "name": "Product", "slug": "product" },
    "placement": {
      "type": "channel",
      "channel": {
        "id": "channel-id",
        "name": "Launch",
        "slug": "launch"
      }
    }
  }
}

Search and recent-thread results also include stable thread IDs, web URLs, and pagination metadata. Thread tools return citation URLs and truncation metadata.

Work with documents

type_documents_list lists Markdown documents you can access, with an optional query for title or content search and limit / offset pagination. type_documents_pull returns a document’s Markdown and its currentRevisionId.

type_documents_push creates or updates a document from inline Markdown; hosted MCP never reads files from your machine.

• To create, pass spaceId, title, and contentMarkdown. You must be a member of that Space.
• To update, pass documentId, contentMarkdown, and the baseRevisionId you received from type_documents_pull. If the document changed since that pull, the update is rejected with a conflict error; pull again before retrying.
• Set public: true to publish a public link. Documents are Space-scoped unless you ask for that explicitly.

Keep the returned document ID for later updates. If you want a local file kept in sync with a Type document, use the Type CLI, which records that mapping for you.

Work with skills

Skills can be organization-wide or attached to a Space. They are not attached to an individual Channel because every Channel shares its Space’s skills. A Space-scoped target requires isMember: true for that Space.

Use one of these exact targets with type_skills_list, type_skills_push, or type_skills_sync:

{ "scope": "global" }

{ "scope": "space", "spaceId": "space-id-returned-by-type_spaces_list" }

A skill package includes a name, a handle, an optional description, and 1–100 files. Each file has a relative filename, a category of script, reference, or asset, its text content, and, for scripts, optional scriptEntrypoint and scriptLanguage (python, javascript, typescript, or shell) values.

type_skills_push creates a new skill. If a skill with the same name already exists for the target, it fails unless you pass force: true, which updates that skill when it is the only match. type_skills_sync updates the skill named by skillId, or creates one when skillId is omitted. type_skills_inspect returns a skill and the full content of its packaged files.

Skill creation and updates are write actions. Review the proposed package and stable Space target in your MCP client before approving them.

Build and publish apps

Type MCP exposes the full Type App lifecycle without a local checkout. Local Vite hosting and file watching remain Type CLI features.

1. Discover an app with type_apps_list or type_apps_resolve.
2. Create a new app in a Space with type_apps_scaffold (spaceRef and title), or open an existing one with type_apps_checkout. Both return the editable file tree and a buildId.
3. Send the complete authored tree with type_apps_save_source, passing the expectedSourceGeneration you received so a stale checkout cannot overwrite newer shared source. Keep the returned checkpoint and source hashes. Sources are limited to 256 files and 8 MiB in total.
4. Deploy that checkpoint to the development backend with type_apps_deploy_development, and resolve preview access with type_apps_resolve_session.
5. Create a reviewable hosted draft with type_apps_prepare.
6. For a new app, publish the first live release with type_apps_publish_first. For an app that is already live, read type_apps_get_publish_approval, review it with the user, then pass the approved hashes to type_apps_publish.
7. Inspect progress with type_apps_get_build and backend logs with type_apps_logs (target of development or production).
8. Manage access with type_apps_get_access, type_apps_set_access (workspace, channel with a spaceRef, or public), and type_apps_share, which creates a public link and optionally allows public data writes.

Publishing, changing access, and sharing change what other people can see. Approve them only after reviewing the draft. There is no rollback tool; publish the desired source as a new draft instead.

Run automations

Automation tools take a space reference and act on that Space’s agent.

Scheduled actions run on a timetable. type_scheduled_actions_create takes name, instructions, and a schedule, plus optional description, channel, slackChannel, and runConfig (model and effort overrides). New actions start disabled unless you pass isEnabled: true; enable or disable later with type_scheduled_actions_update. Use type_scheduled_actions_list, type_scheduled_actions_get, and type_scheduled_actions_delete for the rest of the lifecycle.

Synced events bring outside activity into a Space. type_synced_events_create takes a source of new-thread, slack, github, linear, webhook, rss, or email with source-specific settings: webhook (service, optional secret and signatureHeader), rss (feedUrl and pollIntervalMinutes from 5 to 1440), email (username), and slack (channel and triggerMode). Slack, GitHub, and Linear sources need a connected integration passed as integrationId, and use type_slack_channels to discover Slack destinations. Webhook, RSS, and new-thread sources can be created disabled and switched with type_synced_events_set_enabled; Slack, email, GitHub, and Linear sources must be created enabled and are deleted to stop them. type_synced_events_poll checks an RSS feed now.

type_synced_events_send delivers an inline JSON sample through a webhook you are authorized to use. Pass the signing secret when the webhook verifies signatures. Because it uses the real webhook receiver, it can create messages and trigger AI replies.

type_automations_test runs a scheduled action or event (kind of scheduled or event) and returns a response message ID. Poll type_automations_status with that ID from the client, and review past runs with type_automations_history.

Use integrations

Type keeps OAuth tokens and credentials on the server. The MCP client receives only tool metadata and results, and Type applies the same personal-versus-organization credential selection and permission policy as the rest of Type.

• type_integrations_available lists providers you can connect, type_integrations_connections lists installed personal and organization connections, and type_integrations_list lists the services you can call, each with its stable organizationIntegrationId and effective access mode.
• type_integrations_tools returns the permitted tools and exact argument schemas for one service and organizationIntegrationId. type_integrations_call runs one of them. Read-only connections omit write tools, and calls that send, post, edit, or delete data in another product are consequential; your client should ask before running them, and failed writes should not be retried until you check the provider.
• type_integrations_connect starts a connection for a provider and scope (organization or personal) and returns a Type settings URL. Finish provider OAuth or credential entry there, then poll type_integrations_connection_status with the returned attemptId. type_integrations_create enables a native integration or saves native credentials directly. type_integrations_disconnect removes a personal account (userIntegrationId from the connections list) or, with deleteForOrganization: true, an organization connection (integrationId).
• For Custom APIs, connect with a nonsecret customApiDraft, save the credential with type_integrations_save_custom_api, validate with type_integrations_verify, then call it with type_integrations_request (path, query, headers, and an optional body). Never place a credential in a tool argument or chat message.
• type_integrations_permissions shows integration policies. type_integrations_set_grant sets a workspace, Space, or user grant to read_only or full; type_integrations_delete_grant removes one; type_integrations_set_personal_mode caps your own personal credential. Changing shared grants requires a workspace owner/admin or a manager of that integration.

Authentication and organization access

Type MCP uses OAuth through Type’s identity provider. The organization selected during sign-in scopes the connector token, and Type does not send an API key to the MCP client. Every tool runs as that user in that organization; no tool accepts a caller-supplied organization or actor.

Type MCP must be enabled for your workspace by Type. If it is not, sign-in succeeds but every request returns Type organization access denied.

Operation	Public Space with isMember: false	Space member
Discover the Space	Allowed	Allowed
Read its threads	Allowed	Allowed
List its Channels	Not allowed	Allowed
List, create, or update Space-scoped skills	Not allowed	Allowed
Create documents, send webhook samples, or manage the Space	Not allowed	Allowed, subject to your role

Private Spaces are not exposed to non-members.

type_orgs_list shows every organization you belong to and which one the connector is bound to. To use a different organization, disconnect Type in the client’s connector settings, add it again, and select the new organization during sign-in.

To disconnect Type, remove it from the client’s connector settings. The client owns the saved OAuth connection.

Type MCP or Type CLI?

Use Type MCP when you want a supported AI client to work with Type through a hosted connection with no local installation. It covers the same workspace, document, skill, app, automation, and integration operations as the CLI, with content passed inline instead of as local paths.

Type MCP is also the right choice when an agent runs in a cloud-hosted environment, including Claude Cowork in cloud mode. Cloud compute cannot rely on a type-cli binary installed on your machine.

Use the Type CLI when the workflow depends on your local machine, including:

• Syncing local skill folders and Markdown files with persistent file mappings and dry runs.
• Running a Type App’s frontend locally with type-cli app dev.
• Starting a new Space agent task with type-cli threads create, or moving a local Claude or Codex session into a new Type thread with sessions push. Replying to an existing thread works from either interface (type_thread_reply or type-cli threads reply).
• Running Type operations from shell scripts.

Troubleshooting

• Authorization required or Invalid access token: The client did not send a valid connector token. Reconnect Type in the client’s connector settings.
• Type organization access denied: Your membership is inactive, the selected organization is unavailable, or Type MCP has not been enabled for that workspace. Ask a Type workspace administrator.
• Authentication service unavailable or Type workspace unavailable: Retry after a short delay. Type could not verify the connector token or reach the workspace.
• You must join this Space before listing its Channels: type_spaces_list can return public Spaces with isMember: false. Join the Space before listing its Channels. Public thread reads do not require membership.
• Space not found: Call type_spaces_list and pass the returned stable ID without changing it. Space-scoped skill targets also return this error when you are not a member of the Space.
• Thread not found or Requested threads not found: The thread is not readable by you, or one ID in a type_threads_batch request is invalid. Batch reads fail as a whole.
• Document changed; pull its latest revision before updating: Another edit landed after your pull. Call type_documents_pull again and use the new baseRevisionId.
• A skill named ”…” already exists for this target: Use type_skills_sync with the existing skillId, or pass force: true to type_skills_push.
• Skill package rejected: Use non-empty names and handles, unique relative file paths, and no absolute paths or . / .. path segments.
• Unknown field or invalid_input: Input schemas are strict. Re-read the tool schema from your client and remove fields it does not list.