Checkvist

Checkvist is the keyboard-driven outliner and task list. Agents create checklists, add and update items with tags, due dates, priorities, assignees, and repeats, attach notes, and import or export lists as text.

Verified 21 actions Session available

Checkvist website Platform Documentation Capability data verified 2026-08-24

An incident review closes and its follow-up actions need to become a working list

Agent pulls the owners, dates, and severities out of the review record

Create Checklist opens the list, with the team tag written into the name as smart syntax

Create Item adds each follow-up with its due date, priority, and assignee

List Items reads the flat result back and rebuilds the outline from the parent identifiers

The list link posts to the team channel with the owners named

The review owner approves any rebuild that would replace an existing list rather than extend it

What This Integration Enables

Checkvist is built for people who would rather type than click, and its API keeps that character. Smart syntax is part of the contract rather than a convenience in the interface: a tag written into a checklist name becomes a list tag and is stripped out of the name, and a due date accepts the same shorthand a person would type. An agent that understands this writes less and gets more right, because one well-formed string sets the schedule, the tag, and the priority together.

FlowRunner agents create checklists, add and update items with tags, due dates, priorities, assignees, and repeats, attach notes, and export a whole list as OPML, Markdown, or plain text. The distinctions worth encoding in a flow are the ones Checkvist draws deliberately. Updating an item does not change its status, because there is a separate operation for that. Changing the status of an item that has children changes every child, because in Checkvist a parent's status is only the sum of what sits underneath it. Getting an item returns the item followed by its ancestors, which is a breadcrumb rather than a record. Building against those rules rather than around them is what makes an unattended flow safe to leave running.

Without FlowRunner

Follow-ups scatter on close Actions agreed in a review end up in notes, chat, and three people's heads

Structure is retyped Turning a nested plan into a working list means typing the indentation again by hand

Parent status lies A parent item reads as done while children underneath it are still open

With FlowRunner

Every review ends in a list The agent opens the checklist, files the actions, and names the owners in one pass

Indentation carries across A whole outline is imported in one call, with the nesting taken from the text

Status resolves the way the tool means it The agent uses the status operation deliberately, knowing a parent decides its children

Use Case Scenarios

A review that ends with a list instead of a promise

An incident review closes in the tracker. The agent reads the agreed follow-ups, calls Create Checklist with the team tag written into the name so Checkvist files it correctly and strips the tag out, then adds each action with Create Item. Due dates go in as the shorthand a person would type, so relative dates resolve the way the team says them out loud. Priorities and assignees are set on the same call. The list URL posts to Slack with the owners named, and the agent files the review summary as a note on the first item so context travels with the work.
Reading a nested list back out without flattening it

A weekly rollup needs the state of several project lists. List Items returns every item with a parent identifier and a position rather than a nested structure, so the agent rebuilds the outline before summarizing it, and uses Get Item on anything that needs a breadcrumb, because that call answers with the item followed by each of its parents to the root. Open items are grouped by owner and depth, and the result appends to a sheet in Google Sheets. Because the agent respects the parent-and-children rule, an item that reads as closed is reported as closed only when everything beneath it actually is.
Turning a document into a working outline

A planning document arrives as indented text. Import Items builds the whole structure in one call, with the indentation becoming the hierarchy, which is far faster and far more faithful than creating items one at a time. The agent sets the target list by tag rather than by identifier where the convention allows it, and it always sets the position explicitly, because Checkvist adds imported items to the beginning of a list by default. The one parameter it never sets on its own is the one that replaces the list's existing contents.

Human-in-Loop Highlight

Checkvist is unusually forgiving about deletion and unusually final about replacement, and that asymmetry decides where the gate goes. Delete Checklist only marks a list for removal, and the data goes once a day, so a mistake has a window in which support can still help. Import Items with Replace Existing has no such window: it deletes the list's entire content and puts the imported text in its place immediately, and the vendor's own documentation calls it dangerous. So a FlowRunner agent imports freely when it is adding to a list, and stops when it is replacing one: "This import would replace the whole contents of the Launch Checklist. The list currently holds 62 items, 18 of them open, with notes attached to 9. The import contains 54 items and no notes. Replace the list, or append the new structure under a new parent?" The list owner answers. The paradox is worth stating plainly, because it is the sort of thing a flow author gets backwards: on this connector the delete is recoverable and the rewrite is not.

Agent processes routinely

Detects exception requiring judgment

Clear match Continues automatically

Ambiguous Routes to human via preferred channel

Human decides

Agent resumes with decision

Agent Capabilities

21 actions

Connection and checklists

Get Current User Returns the Checkvist account the connection acts as. It is the cheapest call for confirming a connection is alive before a flow does anything else.
List Checklists Returns the account's checklists, most recently updated first. Skipping the statistics makes the call considerably faster when the per-list task and user counts are not needed.
Get Checklist Returns one checklist with its tags and counts.
Create Checklist Creates a checklist. A tag written into the name becomes a list tag and is stripped out of the name, which is Checkvist's smart syntax working as designed. Making a list public makes it readable by anyone and indexable by search engines, and is a paid-tier setting.
Update Checklist Renames a checklist, changes its tags, or makes it public. The tags parameter replaces the list's tags rather than adding to them, so an empty value clears them and omitting it keeps them.
Delete Checklist Deletes a checklist with everything in it. Checkvist marks it for deletion rather than removing it immediately and clears marked lists once a day, so a mistake has a window in which support can still help.
Export Checklist Exports a whole checklist as OPML, Markdown, or plain text. It is the same address as the read with a different extension, which is why one operation covers the entire export surface.

Items

List Items Returns a checklist's items ordered by parent and position. The result is flat, with each item carrying a parent identifier, so the outline is rebuilt from those.
Get Item Returns one item followed by each of its parents up to the root. It is a list rather than a single record, which is exactly what a breadcrumb needs.
Create Item Adds an item to a checklist. The due date accepts Checkvist's smart syntax, so a relative phrase works as well as a date. Position is one-based, and leaving it empty appends to the end.
Update Item Changes an item's text, parent, tags, due date, priority, position, or assignees. It does not change the status, which has its own operation. Turning smart syntax parsing on has due dates and tags written inside the text recognized.
Change Item Status Closes, reopens, or invalidates an item. Invalidating marks an item as no longer relevant, which is a different statement from done. On an item with children it changes every child, because in Checkvist a parent's status is only the sum of its children's.
Delete Item Deletes an item and everything nested under it, and returns what was removed.
Set Item Repeat Makes an item repeat on a schedule.

Tags and bulk import

Set Item Tags Sets the tags on an item, replacing what was there. One call can tag several items at once. Checkvist separates tags with spaces here, unlike the comma-separated form used when creating an item.
Remove Item Tag Removes one tag from an item, and optionally from several others in the same call.
Import Items Imports a block of text as items, building the outline from its indentation. It is the fastest way to put a whole structure into Checkvist in one call, and the target list may be named by tag rather than by identifier. Its replace option wipes the list's entire content first, which is why it sits behind this page's human gate.

Notes

List Notes Returns the notes attached to one item.
Create Note Adds a note to an item, which is how an agent leaves context where the next person will look for it.
Update Note Rewrites a note.
Delete Note Deletes a note from an item.

Frequently Asked Questions

What can FlowRunner do with Checkvist?

FlowRunner agents can run Get Current User, List Checklists, and Get Checklist in Checkvist, plus 18 more actions.

Does connecting Checkvist to FlowRunner require OAuth?

No. Checkvist connects to FlowRunner with session-based authentication, no OAuth flow required.

Can Checkvist trigger a FlowRunner workflow automatically?

Checkvist doesn't currently expose triggers in FlowRunner. It connects as an action step inside workflows started by another trigger.

Start building with Checkvist

Free plan, no card required. Connect in minutes.

Start Building Free Talk to us