canonical: https://jentic.com/apis/manifest.ly/manifestly

# Manifestly Checklists API

Manifestly is a recurring-process checklist platform used by ops, customer success, and IT teams to run repeatable workflows reliably. The API exposes the platform's core objects - checklists (workflow templates), runs (instances of a checklist), steps, step data, hooks, users, and memberships - under `/api/v1.` Authentication is an API key in the Authorization header. The endpoints support template management (create/update checklists and their steps), run lifecycle (start a run, list, complete steps), and webhook-style hooks at workflow and step level for outbound notifications.

## For AI agents

Run and manage Manifestly recurring-process checklists - workflows, runs, steps, hooks, and users - through an API-key REST API.

## Scope

Does not handle ad-hoc project tasks, document storage, or chat - use for recurring-process checklists, runs, steps, and hooks only.

## Capabilities

- Start a new run of a published checklist with assignees and a due date
- List active and archived checklists in the workspace
- Mark a step on a running checklist as complete
- Create or update a checklist template with its ordered steps
- Register workflow- and step-level hooks for outbound notifications
- Manage workspace users and memberships on individual checklists

## Use cases

### Trigger an onboarding run from a CRM event

Customer success teams trigger a fresh onboarding checklist whenever a new customer reaches a milestone in the CRM. POST /runs starts a run from a published checklist template with the customer name, owner, and due date, and webhook hooks notify the team channel as steps complete. The recurring process now lives in one place rather than ad-hoc CRM tasks.

Example prompt: On a CRM 'customer signed' webhook, start a Manifestly run of the 'New Customer Onboarding' checklist, assign the CSM, and set a 14-day due date.

### Operational compliance reporting

Operations leaders need evidence that recurring processes - closing the books, monthly access reviews - actually ran and were completed on time. GET /runs filtered by checklist and date returns the run history with step completion timestamps, which a reporting job can roll up into a compliance report. The data model is the same one auditors care about.

Example prompt: Pull all runs of the 'Monthly Access Review' checklist for the last quarter and return a table of run id, owner, started_at, completed_at, and overdue flag.

### Step-level integration with downstream tools

Teams want certain steps in a checklist to fire actions in other tools - create a Jira issue, post in Slack, send an email. Step hooks registered via `/steps/{id}/hooks` call out to a webhook receiver when the step is reached or completed, which then bridges to the downstream system. The checklist remains the source of truth for the process.

Example prompt: On the 'Provision laptop' step of the IT onboarding checklist, register a hook that posts to the IT Slack channel when the step is completed.

### Agent-driven process kickoff

An AI agent inside an ops tool can spin up the right checklist based on a free-text trigger ('new vendor onboarding for Acme'). Through Jentic, the agent searches by intent, picks the right checklist template, and calls POST /runs to start the run. The Manifestly API key never appears in the agent's prompt - Jentic's vault holds it.

Example prompt: Given the instruction 'kick off vendor onboarding for Acme Corp', find the matching Manifestly checklist and start a run named 'Acme Corp - Vendor Onboarding'.

## Key endpoints

| Method | Path | Description |
| --- | --- | --- |
| GET | `/checklists` | List checklist templates |
| POST | `/checklists` | Create a checklist template |
| GET | `/checklists/archived` | List archived checklist templates |
| POST | `/checklists/{checklist_id}/steps` | Add a step to a checklist template |
| PUT | `/checklists/{checklist_id}/steps/{step_id}` | Update a step in a checklist template |
| GET | `/checklists/{checklist_id}/steps/{step_id}/data_setting` | Get a step's data settings |

## Key resources

- **Workflows** — Checklist templates with ordered steps
- **Workflow Steps** — Steps inside a checklist template
- **Runs** — Instances of a checklist that are or have been executed
- **Run Steps** — Step instances within a single run, including completion state
- **Workflow Hooks** — Webhooks at workflow level for outbound events
- **Step Hooks** — Webhooks at step level for fine-grained outbound events
- **Users** — Workspace user records and access
- **Memberships** — Per-checklist user assignments

## Why Jentic

- **Setup:** Wiring Manifestly by hand means setting the Authorization header API key, learning the nested /checklists, /steps, and run endpoints, and paging results yourself. Through Jentic you install once, import the Manifestly Checklists API from the API Directory, store the key once, and your agent calls it.
- **Permission scoping:** Manifestly puts the checklist id in the URL path (`/checklists/{checklist_id}/steps`), so a rule can pin your agent to one checklist: it can read and edit that checklist's steps and nothing else. You choose the operations it may call, so creating new checklists is not included unless you add it.
- **Credential handling:** Your Manifestly API key is stored once, encrypted, by your own Jentic One instance and injected at execution time. It never enters the agent's prompt, logs, or context.
- **Discovery method:** Agents search Jentic by intent such as 'start a Manifestly checklist run' or 'add a step to a checklist', and Jentic returns the matching Manifestly operation with its input schema so the agent calls the right endpoint without browsing the reference docs.

## Related APIs

- **Process Street** — Recurring-process checklist platform with similar workflow and run model.
- **Asana** — General-purpose project and task tracker; templates can stand in for checklists.
- **ClickUp** — Project management platform with checklists, templates, and recurring tasks.
- **Zapier Natural Language Actions** — Trigger Manifestly runs from any Zapier-supported event source.

## FAQ

### What authentication does the Manifestly Checklists API use?

Manifestly uses an API key passed in the Authorization header (apiKeyHeader). Keys are generated by workspace admins from the Manifestly settings UI. Through Jentic the API key is stored encrypted in the vault and injected at call time, so the raw key never sits in the agent's transcript.

### Can I start a checklist run through the Manifestly Checklists API?

Yes. POST /runs starts a new run from a published checklist template. The payload references the checklist_id and accepts a run name, owner, and assignees so the run is set up correctly from the moment it starts. List active runs with GET /runs.

### What are the rate limits for the Manifestly Checklists API?

Manifestly's published documentation does not pin a single per-second number; the API throttles per-workspace and returns 429 with a Retry-After header when exceeded. Pace bulk imports of templates or runs and respect the Retry-After value rather than retrying immediately.

### How do I add a step to a checklist template through Jentic?

Run pip install jentic, then search Jentic for 'add a step to a manifestly checklist'. Jentic returns the POST `/checklists/{checklist_id}/steps` operation with its step schema, which you execute with the title, description, and position to add the new step to the template.

### Does the Manifestly Checklists API support webhooks?

Yes, at two levels. Workflow hooks fire on workflow-level events (run started, run completed); step hooks fire on step-level events (step started, step completed). Register both through the hooks endpoints under `/checklists/{id}/hooks` and `/steps/{id}/hooks.`

### Can I capture data inside a checklist run?

Yes. Each step can have data settings configured via the step data setting endpoints, which expose typed fields the assignee fills in during the run. The captured values are returned with the run and can be pulled out by reporting and downstream automations.

### Can I limit what my agent is allowed to do with the Manifestly Checklists API?

Yes. Because Jentic One is self-hosted, you set the rules that decide which Manifestly operations and credentials your agent may use. Manifestly puts the checklist id in the URL path, such as `/checklists/{checklist_id}/steps`, so you can pin the agent to a single checklist where it reads and edits only that checklist's steps and nothing else. You pick the operations it may call, so template creation via POST /checklists or starting runs via POST /runs is excluded unless you explicitly allow it.