Knock
Message users across channels
- Category
- Pending
- Primary Subcategory
- Pending
Integration details
Description
Knock is agent-first customer engagement infrastructure for your product, marketing, and transactional messaging. One platform to manage all your messaging across email, SMS, push, chat, and in-app. Inspect workflows and manage notifications, directly in ChatGPT and Codex.
- Integration type
- Plugin
- Verification status
- Not applicable
- Platform
- ChatGPT
- Category
- Pending
- Primary Subcategory
- Pending
- Secondary Subcategories
- None listed
- Brand
- Unknown
- Access
- Account required
- First tracked
- 2026-09-03
- Tool count
- 24
- Geography
- US
The broad Category that contains the Primary Subcategory.
The Primary Subcategory used for this profile’s headline score.
Other Subcategories where the Integration is listed.
ChatGPT Plugin Discovery Score
ChatGPT Plugin discovery is coming soon
ChatGPT can surface a Plugin when it matches a user's request.Your Plugin Discovery Score measures how often yours appears.
No spam. Unsubscribe any time.
What discovery looks like

Competitive lineup
24 tools agents can invoke
Create or update an object in a specific collection. Objects are used to model custom collections in Knock that are NOT users or tenants. If the object does not exist, it will be created. If the object exists, it will be updated with the provided properties. The update will always perform an upsert operation, so you do not need to provide the full properties each time. Use this tool when you need to create a new object, or update an existing custom-object. Custom objects can be used to subscribe users' to as lists, and also send non-user facing notifications to.
upsert_object
Creates or updates a tenant using the properties provided. Tenants in Knock are used to model organizations, teams, and other groups of users. They are a special type of object. Use this tool when you need to create a new tenant, or update an existing tenant's properties.
upsert_tenant
Creates a new user if they don't exist, or updates the user object for the given userId, including email, name, phone number, and any custom properties. Use this tool when you need to update a user's profile. If the userId is not provided, it will use the userId from the config.
upsert_user
This is the Management API: workflows, channels, templates, commits, and configuration. This session allows **read and write**. Use `execute_mapi_read` for `GET` and `execute_mapi_write` for `POST`/`PUT`/`PATCH`/`DELETE`. Use this tool (Code Mode: `execute_mapi_read`) for **read-only** `MAPI` calls at https://control.knock.app via `mapi.request({ method: "GET", ... })`. Use `search_mapi` first to find paths and request shapes. Auth headers are added on the host. For create/update/delete, use `execute_mapi_write` instead. **mapi.request() response shape:** does NOT return the API JSON body directly. It wraps it: ```json { "status": 200, "ok": true, "result": { /* actual API response body */ } } ``` Always read API fields from `res.result`, not from `res` (e.g. `res.result.entries`, not `res.entries`). When the user asks for the "exact result," return the full `mapi.request(...)` value unless they ask for a projection. Types: interface RequestOptions { method: "GET"; path: string; query?: Record<string, string | number | boolean | undefined>; headers?: Record<string, string>; } /** Wrapper returned by mapi.request() — the API body is in `result`, not at the top level. */ interface RequestResponse { status: number; ok: boolean; result: unknown; } declare const mapi: { request(options: RequestOptions): Promise<RequestResponse> }; Your code must be a single JavaScript async arrow function (no TypeScript). Example: async () => { const res = await mapi.request({ method: "GET", path: "/v1/workflows", query: { environment: "development" }, }); return { status: res.status, entries: res.result.entries, page_info: res.result.page_info }; }
execute_mapi_read
This is the Management API: workflows, channels, templates, commits, and configuration. This session allows **read and write**. Use `execute_mapi_read` for `GET` and `execute_mapi_write` for `POST`/`PUT`/`PATCH`/`DELETE`. Use this tool (Code Mode: `execute_mapi_write`) for **write** `MAPI` calls at https://control.knock.app via `mapi.request({ method: "POST"|"PUT"|"PATCH"|"DELETE", ... })`. Use `search_mapi` first to find paths and request shapes. Auth headers are added on the host. For `GET`, use `execute_mapi_read` instead. **mapi.request() response shape:** does NOT return the API JSON body directly. It wraps it: ```json { "status": 200, "ok": true, "result": { /* actual API response body */ } } ``` Always read API fields from `res.result`, not from `res` (e.g. `res.result.entries`, not `res.entries`). When the user asks for the "exact result," return the full `mapi.request(...)` value unless they ask for a projection. Types: interface RequestOptions { method: "POST" | "PUT" | "PATCH" | "DELETE"; path: string; query?: Record<string, string | number | boolean | undefined>; body?: unknown; contentType?: string; rawBody?: boolean; headers?: Record<string, string>; } /** Wrapper returned by mapi.request() — the API body is in `result`, not at the top level. */ interface RequestResponse { status: number; ok: boolean; result: unknown; } declare const mapi: { request(options: RequestOptions): Promise<RequestResponse> }; Your code must be a single JavaScript async arrow function (no TypeScript). Example: async () => { const res = await mapi.request({ method: "PUT", path: "/v1/workflows/welcome", query: { environment: "development" }, body: { name: "Welcome", steps: [] }, }); return { status: res.status, result: res.result }; }
execute_mapi_write
Poll an in-progress Knock agent session and return a consolidated result (agent text, tool calls, modified resources, and a Status line). When to use: - After start_knock_agent returns Status: running. - When resuming after an MCP disconnect (you still have the session_id). How to use: 1. Call with the session_id from start_knock_agent (or a prior get_knock_agent). 2. Read the Status line in the tool result — you do not parse raw events; the server consolidates them for you. 3. If Status is running, wait a few seconds and call get_knock_agent again with the same session_id. 4. If Status is complete, the run succeeded — use the agent response. 5. If Status is error, the run failed — read the Error line. The Knock agent keeps running on the backend between your polls; each call is short-lived.
get_knock_agent
Retrieves a single message by its ID, including its current status and engagement statuses (e.g. seen, read, interacted, link_clicked). Use this tool when you need to check the delivery status or engagement state of a specific message.
get_message
Retrieves the complete contents of a single message, specified by the messageId. The message contents includes the rendered template that was sent to the recipient. Use this tool when you want to surface information about the emails, SMS, and push notifications that were sent to a user.
get_message_content
Retrieves the delivery logs for a specific message. Delivery logs contain details about each delivery attempt, including any errors that occurred. Use this tool when you need to debug why a message was not delivered or to inspect delivery attempt details.
get_message_delivery_logs
Retrieves the event timeline for a specific message. Events include delivery, bounce, open, click, and other engagement events. Use this tool when you need to see the full lifecycle of a message.
get_message_events
Get an object wihin a collection. Returns information about the object including any custom properties. Use this tool when you need to retrieve an object to understand it's properties.
get_object
Retrieves a tenant by their ID. Tenants in Knock are used to model organizations, teams, and other groups of users. They are a special type of object. Use this tool when you need to lookup the information about a tenant, including name, and if there are any custom properties set.
get_tenant
Retrieves the complete user object for the given userId, including email, name, phone number, and any custom properties. Use this tool when you need to retrieve a user's complete profile. If the userId is not provided, it will use the userId from the config.
get_user
Retrieves the messages that this user has received from the service. Use this tool when you need information about the notifications that the user has received, including if the message has been read, seen, or interacted with. This will return a list of messages across all of the channels. If the userId is not provided, it will use the userId from the config.
get_user_messages
Retrieves the user's notification preferences for the given userId. If the userId is not provided, it will use the userId from the config.
get_user_preferences
Lists all environments available, returning the slug and name of each environment. Use this tool when you need to see what environments are available.
list_environments
List all objects in a single collection. Objects are used to model custom collections in Knock that are NOT users or tenants. Use this tool when you need to return a paginated list of objects in a single collection.
list_objects
Retrieves a list of tenants. Tenants in Knock are used to model organizations, teams, and other groups of users. They are a special type of object. Use this tool when you need to list all tenants in an environment.
list_tenants
This is the Management API: workflows, channels, templates, commits, and configuration. This session allows **read and write**. Use `execute_mapi_read` for `GET` and `execute_mapi_write` for `POST`/`PUT`/`PATCH`/`DELETE`. Use `search_mapi` to explore or filter the OpenAPI spec for the **mapi** API before calling `execute_mapi_read` or `execute_mapi_write`. All $ref pointers are pre-resolved inline. Types: // OpenAPI 3.x spec with $refs resolved inline. interface OperationObject { summary?: string; description?: string; operationId?: string; tags?: string[]; parameters?: Array<{ name: string; in: "query" | "header" | "path" | "cookie"; required?: boolean; schema?: unknown; description?: string; }>; requestBody?: { required?: boolean; content?: Record<string, { schema?: unknown }> }; responses?: Record<string, { content?: Record<string, { schema?: unknown }> }>; } interface PathItem { get?: OperationObject; post?: OperationObject; put?: OperationObject; patch?: OperationObject; delete?: OperationObject; } interface OpenApiSpec { openapi: string; info: { title: string; version: string; description?: string }; paths: Record<string, PathItem>; servers?: Array<{ url: string }>; components?: Record<string, unknown>; tags?: Array<{ name: string; description?: string }>; } declare const mapi: { spec(): Promise<OpenApiSpec> }; Your code must be a single JavaScript async arrow function (no TypeScript) that returns a small, filtered result. Example: async () => { const spec = await mapi.spec(); return Object.keys(spec.paths).slice(0, 20); }
search_mapi
Search the Knock documentation for a given query
search_documentation
Overwrites the user's notification preferences for the given userId. Allows setting per-workflow, per-category, or per-channel notification preferences. Use this tool when you are asked to update a user's notification preferences. If the userId is not provided, it will use the userId from the config. Instructions: - You must ALWAYS provide a full preference set to this tool. - When setting per-workflow preferences, the key in the object should be the workflow key. - Workflow and category preferences should always have channel types underneath. - The channel types available to you are: email, sms, push, chat, and in_app_feed. - To turn OFF a preference, you must set it to false. - To turn ON a preference, you must set it to true. <examples> <example> <description> Update the user's preferences to turn off email notifications for the "welcome" workflow. </description> <input> { "workflows": { "welcome": { "channel_types": { "email": false } } } } </example> </examples>
set_user_preferences
Use Knock's hosted agent to create and update workflows, broadcasts, guides, email layouts, partials, and translations. Prefer this tool when creating or updating those resources in a Knock account — the hosted agent has full account context and usually needs fewer tokens than calling the Management API directly. Use Management API code mode (`search_mapi` / `execute_mapi_read` / `execute_mapi_write`) when you need a specific API call, or when the user asks to use the API. For analytics questions, the Knock agent can return high-level message and engagement data. Those queries are not available through the Management API. Pass the user's request verbatim in prompt. Do not reinterpret or shorten it. This tool waits up to ~45 seconds, then returns a consolidated result. Read the Status line in the response: - Status: complete — the run finished; use the agent response and modified resources. - Status: error — the run failed; read the Error line. - Status: running — the run is still going; save the Session ID and poll with get_knock_agent until Status is complete or error. Agents can support follow-up runs by passing in the returned session_id. Use a follow-up run only for related edits or questions about a resource you just modified. Otherwise, use the Management API or start a new agent session.
start_knock_agent
Subscribe a list of users to an object in a specific collection. We use this to model lists of users, for pub-sub use cases. Use this tool when you need to subscribe one or more users to an object where you will then trigger workflows for those lists of users to send notifications to. Before using this tool, you should create the object in the collection using the createOrUpdateObject tool.
subscribe_users_to_object
Unsubscribe a list of users from an object in a specific collection. We use this to model lists of users, for pub-sub use cases. Use this tool when you need to unsubscribe one or more users from an object where you will then trigger workflows for those lists of users to send notifications to.
unsubscribe_users_from_object
How do I improve a ChatGPT Plugin's discoverability?
The levers are the listing surface agents actually read: names, descriptions, keywords, tool metadata, and registry health. Which lever matters depends on where discovery breaks, which is what continuous measurement shows.
Where is this profile measured?
This profile uses the geography attached to the latest public registry snapshot: US. Locale tags are intentionally omitted.