canonical: https://jentic.com/apis/knock.app/knock

# Knock App Knock API

The Knock API sends and manages product notifications across channels. It triggers notification workflows for recipients, tracks the resulting messages, identifies and updates users, and reads or sets each user's channel data and notification preferences. Responses are JSON, so an agent can notify users, check delivery, and manage who receives what without building its own notification pipeline.

## For AI agents

Trigger notification workflows, track sent messages, and manage users, preferences, and channel data across notification channels.

## Scope

Sends and tracks notifications only; it does not author workflow templates or manage channel provider credentials, which are configured in the Knock dashboard.

## Capabilities

- Trigger notification workflows for one or many recipients
- List and inspect messages and their delivery events
- Identify, update, and merge users
- Read and set user notification preferences
- Manage per-channel user data
- Mark messages seen, read, or archived

## Use cases

### Trigger notifications from a workflow

Product events such as a new comment or a completed order should reach users through the right channel. The Knock API triggers a configured workflow for one or more recipients, letting an application fire a notification without hardcoding channel logic. A single trigger can fan out to email, push, and in-app channels defined in the workflow.

Example prompt: Trigger the named notification workflow for a recipient when a product event occurs.

### Track message delivery

Knowing whether a notification arrived matters for support and follow-up. The Knock API lists messages and their delivery events, so an application can confirm delivery, inspect content, and see engagement without a separate logging system. Message events record each state change from send to read.

Example prompt: Retrieve the delivery status and events for a message sent to a user.

### Manage users and preferences

Notifications depend on accurate recipient data and honored preferences. The Knock API identifies and updates users, stores per-channel data such as device tokens, and reads or sets notification preferences, letting an application keep recipients and their opt-ins current. Preferences can gate which workflows reach a user.

Example prompt: Update a user's notification preferences to opt them out of a category.

### Agent-managed notifications

An AI agent can send and manage notifications for a user without a developer wiring each call. Through Jentic the agent matches an intent such as 'notify the account owner that the report is ready' to the Knock trigger operation, runs it, and can check the resulting message. The API key stays in the user's Jentic One instance and never reaches the agent's prompt.

Example prompt: Trigger a notification workflow for the requested recipient and confirm the message was created.

## Key endpoints

| Method | Path | Description |
| --- | --- | --- |
| POST | `/workflows/{key}/trigger` | Trigger a notification workflow for one or more recipients. |
| GET | `/messages` | List messages sent through Knock. |
| GET | `/users/{user_id}` | Retrieve a user's profile. |
| PUT | `/users/{user_id}` | Identify or update a user. |
| GET | `/users/{user_id}/preferences` | List a user's notification preferences. |
| POST | `/workflows/{key}/cancel` | Cancel a triggered workflow. |

## Key resources

- **Workflows** — Trigger and cancel notification workflows for recipients.
- **Messages** — List messages, read content, and track delivery events.
- **Users** — Identify users and manage their preferences and channel data.
- **Objects** — Store and subscribe non-user entities to notifications.

## Why Jentic

- **Setup:** Wiring Knock yourself means managing a Bearer secret key, mapping product events to workflow triggers, and reading message events to confirm delivery. With Jentic you install once, import Knock from the API Directory, and store the key a single time.
- **Permission scoping:** Jentic lets you grant your agent only the operations it needs, such as triggering workflows and reading messages without user deletion or bulk operations, and enforces that on every call.
- **Credential handling:** Your Knock API key is stored once, encrypted, by your own Jentic One instance. It is injected when a call runs and never enters the agent's prompt, logs, or context.
- **Discovery method:** Agents find Knock through Jentic's intent search, matching a request like 'notify the user their export is ready' to the right operation without hardcoded endpoints.

## Related APIs

- **OneSignal** — Customer messaging and multi-channel notification platform.
- **Twilio Notify** — Multi-channel notification delivery over SMS, push, and more.
- **SendGrid Mail** — Transactional and marketing email delivery.

## FAQ

### What can an AI agent do with the Knock API through Jentic?

An agent can trigger notification workflows, track the messages they produce, and manage users, preferences, and channel data. Through Jentic the agent matches an intent to the right operation and runs it with your API key injected at execution time.

### How do I authenticate with the Knock API?

Knock authenticates every request with a Bearer token, your API secret key sent in the Authorization header. You store the key once in your Jentic One instance, and it is added to each call at run time rather than exposed to the agent.

### Can Knock send notifications across multiple channels?

Yes. A single workflow trigger can fan out to the channels configured in Knock, such as email, push, and in-app feeds, based on each recipient's preferences. The API reports the messages produced for each channel so you can track delivery.

### Does the Knock API document rate limits?

The OpenAPI specification does not state rate limits; request allowances depend on your Knock plan. Check the current limits for your account in the Knock dashboard and documentation at https://docs.knock.app.

### Can I restrict what my agent is allowed to do with the Knock API?

Yes. Jentic lets you allow only the operations your agent needs, for example triggering workflows and reading messages while withholding user deletion and bulk operations. Your Jentic One instance enforces that boundary on every call and keeps the API key outside the agent's context.