Workflow Runs workflow_runs
Workflow runs: list runs, read one run's step trace, and recover runs. Retry a needs_attention run after fixing its setup problem; restart re-runs failed steps in place and keeps paid outputs; replay makes a new linked run. Bulk takes run ids or a filter (1,000 per call). Run-on-records starts a live workflow on up to 1,000 records: call it with estimate_only first and show the credits. A workflow's audit log (edits, publishes, run events) is activity with its workflow_id; account list is the workspace-wide log.
Call it from an MCP client connected to https://mcp.ken.so/mcp: reads go through workflow_runs_read and changes through workflow_runs_write. Each takes operation plus that operation's parameters, and your workspace role decides which operations you see.
Each operation with a route calls the Kenso API at https://api.ken.so with Authorization: Bearer <Kenso API key>, Ken-Version: 1.1 and X-Ken-Workspace-Id: <workspace id>. You can call that route directly with the same headers.
Operations: activity, bulk, cancel, browser-runs-create, browser-runs-get, get, browser-runs-list, revival-candidates-list, revivals-list, list, replay, restart, retry, run-on-records, set-step-output, skip-step, step-overview, browser-runs-summary, revivals-summary
activity
Read. Early access: needs workflows on for the workspace. GET https://api.ken.so/v1/workflows/{workflowId}/activity
Path: workflowId
Query: cursor string, eventType string, limit integer
List a workflow's audit log, newest first. Edits, publishes and status changes, plus its runs starting, completing and being recovered. Filter by event type.
GET /api/v1/workflows/{workflowId}/activity. Staff. Sends Ken-Version 1.1.
Requires workflows view. limit 1 to 200 (default 50); pass
pagination.nextCursor back as cursor. Run events and field saves (one per
record a run saves) cover the last 90 days.
event_type: one or more event types, comma-separated (any of them), from
the list below; left out, every type. An unknown type answers 400
validation_failed naming the accepted types.
Returns {data: [{id, eventType, subjectType, subjectId, actor, occurredAt,
payload}], pagination}. eventType is workflow.created,
workflow.draft_saved, workflow.published, workflow.unpublished,
workflow.restored, workflow.status_changed, workflow.auto_paused,
workflow.deleted, workflow.field_saved, workflow.reworded (a save that
changed only the words and copied them onto the published version),
workflow_run.started,
workflow_run.completed, workflow_run.cancelled, workflow_run.restarted,
workflow_run.replayed, workflow_run.step_skipped or
workflow_run.step_output_set. A deleted workflow answers 404, so
workflow.deleted never shows.
subjectType is workflow (subjectId is the
workflow) or workflow_run (subjectId is the run). actor is {kind, userId,
clientName}; clientName is the client the change came through, such as
Claude Code. payload holds the event's details.
Example: workflow_id=12, event_type="workflow.published,workflow_run.completed"
bulk
Write. Early access: needs workflows on for the workspace.
Cancel, restart, retry or skip a step of many runs: by run_ids, or by a filter on one workflow's runs (1,000 per call). Each run gets its own result; while truncated is true, call again with cursor set to nextCursor.
POST /api/v1/workflow-runs/bulk-cancel, bulk-restart, bulk-retry or
bulk-skip. Staff. Sends Ken-Version 1.1. Requires workflows edit.
action: cancel, restart, retry or skip (the single-run operations of the
same name; skip is skip-step and needs node_id, the step to skip in every
run: a run where that step is not skippable answers invalid_state). Send exactly one of run_ids (1 to 1,000 distinct run ids, done in
that order) and workflow_id (a filter: that workflow's runs, newest first,
narrowed by status (comma-separated), is_test, created_after and
created_before). A filter takes only runs the action can change (cancel:
unfinished runs; restart: failed, needs_attention, over_limit; retry:
unfinished runs, needs_attention when status is omitted; skip: needs_attention
and failed runs when status is omitted, else the status you name among
running, waiting, needs_attention and failed), stops at 1,000
runs and sets truncated: true and nextCursor when more matched: call again
with the same filter and cursor=nextCursor to process the older runs, until
truncated is false. The cursor pages past runs that stay in the filter (a
retried running run, a run where node_id is not skippable). cursor is only
for a filter; an invalid one answers 400 invalid_cursor.
Returns {data: {succeeded, failed, truncated, nextCursor, results: [{runId,
status, error}]}}. status is cancelled, restarted, retried or skipped on success, else
not_found, invalid_state (the run is in the wrong status; error says which)
or failed. The call answers 200 even when every run fails, and 400 only
when the request itself is invalid.
Example: action="retry", workflow_id=12, status="needs_attention"
Example: action="skip", workflow_id=12, node_id="email"
Example: action="skip", workflow_id=12, node_id="email", cursor="638000000000000000:4512"
cancel
Write. Early access: needs workflows on for the workspace. POST https://api.ken.so/v1/workflow-runs/{runId}/cancel
Path: runId
Cancel a workflow run where it is: its queued and waiting steps do not run. A finished run answers 409 invalid_state.
POST /api/v1/workflow-runs/{runId}/cancel. Staff. Sends Ken-Version 1.1.
Requires workflows edit. Returns the run after the cancel. A run that is
already succeeded, failed or cancelled answers 409 invalid_state ("Run is
already <status>."); 404 not_found for a run outside the workspace.
Cancelling a run sends nothing.
browser-runs-create
Write. Early access: needs agent_work, browser_steps, workflows on for the workspace. POST https://api.ken.so/v1/browser-runs
Body (json): instruction string, maxMinutes integer, startUrl string
Start a read-only browser run outside a workflow: Ken opens start_url and works the instruction on that site. Read the result with workflow_runs(operation="browser-runs-get") and the returned id.
POST /api/v1/browser-runs. Staff. Sends Ken-Version 1.1.
Requires workflows edit. Returns 404 not_found unless the workspace has the
workflows, browser_steps and agent_work features on and Kenso has turned
browser runs outside a workflow on. The run never submits a form and stays
on start_url's site.
instruction: what to do on the site, at most 8,000 characters.
start_url: an http or https URL on a public domain, at most 2,048 characters.
max_minutes: browser minutes, 1 to 10 (default 5).
idempotency_key: optional, 1 to 200 characters, sent as Idempotency-Key (a
new one is made for each call when absent). Retry a call with the same key
and it returns the first run (Idempotent-Replayed: true) instead of starting
and charging another; the same key with other values is 422
idempotency_key_reused. A refusal is not kept under the key.
Holds max_minutes x 150.3 credits when the run is queued; when it ends,
charges 0.3 credits a started browser minute plus the run's AI work and
releases the rest. A failed run charges nothing. 402 plan_limit_reached
(refusal INSUFFICIENT_CREDITS) when the workspace cannot cover the hold;
429 rate_limited past the workspace's browser runs for the day.
Returns {data: the run as browser-runs-get returns it, with status
queued}. A field with no value is left out.
Before the backend ships the route this returns success false with
error.code not_available.
Example: instruction="List the plan names and monthly prices", start_url="https://northwindlogistics.com/pricing", max_minutes=3
browser-runs-get
Read. Early access: needs browser_steps, workflows on for the workspace. GET https://api.ken.so/v1/browser-runs/{browserRunId}
Path: browserRunId
Read one browser run in full: status and reason, quotes, screenshot URLs, the fields sent, the replay link, credits and the first human reply. The detail behind a run-history row.
GET /api/v1/browser-runs/{browserRunId}. Staff. Sends Ken-Version 1.1.
Requires workflows view. Returns 404 not_found unless the workspace has the
workflows and browser_steps features on, and for a run of another
workspace.
Returns {data: {id, workflowId, runId, stepRunId, nodeId, recordType,
recordId, status, reason, canSubmit, startUrl, site, task, identity
{title, phone, company}, inbox {name, email}, result (the outputSchema
object), quotes [{text, url, note}], screenshots [{n, url, caption, at}]
(url is the JPEG route /v1/browser-runs/{id}/screenshots/{n}; fetch it
with the caller's credential, not through a tool), replayUrl (left out
once replayExpiresAt has passed), replayExpiresAt, submission {url, fields
[{label, value}] (what Ken put in each form field: the inbox, the identity
and the step's fields answers, each value up to 4,000 characters), files
[{field, label, name}] (each uploaded file and the form field it went
into)}, watchedDomains, watchDays, maxMinutes, submittedAt,
startedAt, endedAt, browserSeconds, browserMinutes, creditsMillicredits,
credits, charged, screenshotCount, hasReplay, firstHumanReplyAt,
secondsToFirstHumanReply, error, driver, provider, createdAt,
modifiedAt}}. A field with no value is left out.
Before the backend ships the route this returns success false with
error.code not_available.
Example: browser_run_id=9001
get
Read. Early access: needs workflows on for the workspace. GET https://api.ken.so/v1/workflow-runs/{runId}
Path: runId
Read one workflow run with its full step trace: every step, its input, output, error and attempts. Use it to see why a run failed or what a step produced.
GET /api/v1/workflow-runs/{runId}. Staff. Sends Ken-Version 1.1. Requires
workflows view. 404 not_found for a run outside the workspace.
Returns {data: {...the run as in list, steps: [{id, nodeId, iteration,
stepType, status, attempt, lane, pool, providerKey, input, output,
errorClass, errorMessage, creditsMillicredits, fusedIntoStepRunId,
startedAt, endedAt, createdAt, attempts: [{attempt, status, errorClass,
message, retryAfter, creditsMillicredits, log, startedAt, endedAt}]}]}}.
Steps come in the order they were created; iteration is
"<forEachId>:<index>" inside a for-each. Step status is queued, running,
waiting, succeeded, failed, failed_safely (failed but the workflow went
on), skipped or cancelled. errorClass is temporary, permanent, setup or
budget. Seven days after a run finishes, its succeeded steps lose input,
output and attempt logs (omitted) unless the workflow keeps success
details. A finished run keeps its steps for 90 days and its summary
(steps empty) for 400 days.
browser-runs-list
Read. Early access: needs browser_steps, workflows on for the workspace. GET https://api.ken.so/v1/browser-runs
Query: cursor string, limit integer, nodeId string, recordId integer, recordType string, runId integer, status string, workflowId integer
List a workspace's browser runs, newest first: what each browser.run step did for each record and what it cost. Filter by workflow, workflow run, step (node_id), record or status.
GET /api/v1/browser-runs. Staff. Sends Ken-Version 1.1. Requires workflows
view. Returns 404 not_found unless the workspace has the workflows and
browser_steps features on.
workflow_id, run_id (the workflow run the browser runs belong to), node_id
(the browser step's id in the workflow), record_type (account, person,
lead, place or none) with record_id, status (one of queued,
awaiting_approval, declined, running, done, confirmed, unconfirmed,
blocked, out_of_browser_time, failed). Items carry no quotes, screenshots
or submission: read one with workflow_runs(operation="browser-runs-get").
limit 1 to 200 (default 50); pass pagination.nextCursor back as cursor.
Returns {data: [{id, workflowId, runId, stepRunId, nodeId, recordType,
recordId, status, reason, canSubmit, startUrl, site, submittedAt,
startedAt, endedAt, browserSeconds, browserMinutes, creditsMillicredits,
credits, charged, screenshotCount, hasReplay, createdAt, modifiedAt}],
pagination: {nextCursor, hasMore}}. A field with no value is left out.
Only done and confirmed runs back a claim; a failed run was not charged.
Before the backend ships the route this returns success false with
error.code not_available.
Example: workflow_id=500, node_id="test", status="confirmed"
revival-candidates-list
Read. Early access: needs lead_revival, workflows on for the workspace. GET https://api.ken.so/v1/revival-candidates
Query: classes string, cursor string, dueBefore date-time, limit integer, repliedAfter date-time, repliedBefore date-time, revivable boolean
List past replies Ken could revive, one per person, with when Ken would follow up and whether it may now. The existing pile of objections, out-of-office and interested replies; start runs on the contactIds.
GET /api/v1/revival-candidates. Staff. Sends Ken-Version 1.1. Requires
workflows view. Returns 404 not_found unless the workspace has the
workflows and lead_revival features on.
Each person's latest inbound campaign reply received in [replied_after,
replied_before) (ISO-8601; default the last 180 days; replied_after at most
730 days ago), kept when its class is one of classes (comma-separated:
objection, out_of_office, interested, the default being all three, and
negative, which is never revivable). A person is every contact of the
workspace with the same email. Each item is checked as lead.revival_check@1
does with its defaults (365-day cooldown, open opportunity skips, 10%
holdout, 14 quiet days). revivable: only candidates Ken may follow up on now
(true) or only those it may not (false). due_before (exclusive): only
candidates whose followUpAt is before it. Those two filter the checked page,
so a page may hold fewer than limit items while pagination.hasMore is true.
limit 1 to 50 (default 25; each item is one check); pass
pagination.nextCursor back as cursor.
Returns {data: [{contactId, email, name, campaignId, messageId (msg_),
threadId (thr_), classification, receivedAt, followUpAt, followUpSource
(asked, out_of_office or none), revivable, reason}], pagination:
{nextCursor, hasMore}}. reason, when revivable is false: not_found,
class_not_revivable, negative_not_allowed, not_due, non_engageable,
suppressed, replied_again, thread_active, in_sequence, meeting_booked,
open_opportunity, cooldown or holdout. Start revivals with workflow_runs
run-on-records (record type lead) on the contactIds.
Before the backend ships the route this returns success false with
error.code not_available.
Example: classes="objection", revivable=true, limit=20
revivals-list
Read. Early access: needs lead_revival, workflows on for the workspace. GET https://api.ken.so/v1/revivals
Query: contactId integer, cursor string, limit integer, status string, threadId string, workflowId integer
List the workspace's revivals, newest first: a lead's waiting or finished revival and its status. Filter by lead, thread, workflow or status.
GET /api/v1/revivals. Staff. Sends Ken-Version 1.1. Requires workflows
view. Returns 404 not_found unless the workspace has the workflows and
lead_revival features on.
contact_id: the lead. thread_id: a thr_ email thread id (400 when it does
not decode). workflow_id: one workflow's revivals. status: one or more,
comma-separated (any of them): waiting (for the follow-up date, nothing
drafted yet), drafted (the revival or its follow-up waits in the thread for
a person to send it), revived (sent, no answer yet), replied (the person
replied after the send), meeting_booked (a meeting was booked after the
send), skipped (see reason: the check's, holdout included, or the draft
step's, e.g. no_inbox), cancelled, expired (nobody sent the draft in time)
or failed. With status a page reads at most 1,000 runs and may hold fewer
than limit items while pagination.hasMore is true. Test and shadow runs are
never revivals. limit 1 to 200 (default 50); pass pagination.nextCursor back
as cursor.
Returns {data: [{runId, workflowId, contactId, threadId (thr_),
classification, followUpAt, followUpSource, status, reason, sentAt,
followUpSentAt, createdAt}], pagination: {nextCursor, hasMore}}. Cancel a
revival with workflow_runs cancel on its runId; read its steps with
workflow_runs get.
Before the backend ships the route this returns success false with
error.code not_available.
Example: contact_id=42
list
Read. Early access: needs workflows on for the workspace. GET https://api.ken.so/v1/workflow-runs
Query: createdAfter date-time, createdBefore date-time, cursor string, isShadow boolean, isTest boolean, limit integer, recordId integer, recordType string, status string, workflowId integer
List the workspace's workflow runs, newest first, without their steps. Filter by workflow, status, record, test flag or creation time.
GET /api/v1/workflow-runs. Staff. Sends Ken-Version 1.1. Requires workflows
view. Returns 404 not_found unless the workspace has the workflows feature on.
workflow_id: one workflow's runs. status: one or more run statuses,
comma-separated (any of them): queued, running, waiting (parked on an event
or a delay), needs_attention (stopped on a setup problem; fix it, then use
retry), succeeded, failed, cancelled, over_limit (held by the workflow's
event run cap; restart it later). record_type: account, person, lead, place
or none, with record_id for one record's runs; a place run's recordId is its
place id: plc_ + recordId (record_id=7 for plc_7). is_test: only test runs (true)
or only real runs (false). is_shadow (Kenso staff only; the API ignores it
for anyone else): true lists only shadow runs, the engine runs that call
live providers but write, charge and notify nothing; left out or false,
shadow runs are hidden. created_after (inclusive) and created_before
(exclusive) are ISO-8601 timestamps; created_before must be later.
limit 1 to 200 (default 50); pass pagination.nextCursor back as cursor.
Returns {data: [{id, workflowId, versionId, status, recordType, recordId,
recordName, isTest, isShadow, lane, triggerType, triggerPayload, sourceId,
triggeredBy, parentRunId, retryOfRunId, replayOfRunId, replayFromNodeId,
needsAttentionReason, creditsReservedMillicredits, creditsChargedMillicredits,
creditsCharged, createdAt, startedAt, endedAt, modifiedAt}], pagination:
{nextCursor, hasMore}}. Use workflow_runs get for one run's steps.
recordName is a lead's or person's name when the caller may read that record
(leads with campaigns view, people with the accounts feature and accounts
view); null for other record types and when the name is not known.
sourceId is the data source that started the run in a workflow with
sources ("trigger" for the first one, else an additionalTriggers[].id);
null without sources, on a test run and on a run started on picked records.
Example: workflow_id=12, status="failed,needs_attention", limit=20
replay
Write. Early access: needs workflows on for the workspace. POST https://api.ken.so/v1/workflow-runs/{runId}/replay
Path: runId
Body (json): fromNodeId string
Replay a run as a new linked run, optionally from one step; the source run is left as it is. Without from_node_id every step runs (and is charged) again.
POST /api/v1/workflow-runs/{runId}/replay. Staff. Sends Ken-Version 1.1.
Requires workflows edit. Returns 201 with the new run (replayOfRunId is the
source); the source may be in any status, including running.
Replay makes a new run with the same version, record, trigger payload,
lane and test flag. A replay of a test run whose draft was saved since the
source run started fails at once with draft_changed: test the draft again
with workflow_builder(operation="test", ...) instead. Restart instead
re-runs failed steps in the same run and keeps paid outputs.
from_node_id: a step id of the run's definition.
Steps the replay does not reach from it keep their outputs when they
succeeded (not run or charged again); a step inside a for-each replays from
its for-each. An unknown step answers 400 with error.details[0].code
unknown_node. A run whose step outputs were compacted, or a workflow that
is no longer live, answers 409 invalid_state.
Example: run_id=901, from_node_id="qualify"
restart
Write. Early access: needs workflows on for the workspace. POST https://api.ken.so/v1/workflow-runs/{runId}/restart
Path: runId
Restart a failed, needs_attention or over_limit run in place: only its failed steps run again. Succeeded steps keep their outputs and are not charged again.
POST /api/v1/workflow-runs/{runId}/restart. Staff. Sends Ken-Version 1.1.
Requires workflows edit. Returns the run after the restart.
Restart re-runs the run's failed steps in the same run and keeps the paid
outputs of the steps that succeeded. Replay instead makes a new linked
run. Allowed only from failed, needs_attention or over_limit; any other
status answers 409 invalid_state. An over_limit run whose workflow is still
over its event limit answers 409 invalid_state ("Workflow is still over its
event limit; try again later."), and so does a failed run whose step data
was already compacted (7 days) or deleted (90 days): replay it instead.
retry
Write. Early access: needs workflows on for the workspace. POST https://api.ken.so/v1/workflow-runs/{runId}/retry
Path: runId
Retry now: resume a run parked in needs_attention once its setup problem is fixed, or skip a retry wait. Calling it again is harmless.
POST /api/v1/workflow-runs/{runId}/retry. Staff. Sends Ken-Version 1.1.
Requires workflows edit.
Use it after you fix what put the run in needs_attention (a missing
connection or secret, a provider limit): every waiting step of the run
becomes due now and the run goes back to running. It also releases a step
waiting out a retry backoff. Returns {data: {runId, stepsReleased,
status}}; stepsReleased is 0 when there was nothing to release. A finished
run (succeeded, failed, cancelled) answers 409 invalid_state: restart or
replay it instead. So does a needs_attention run with nothing queued to
release (for example its definition stopped validating): restart it.
run-on-records
Write. Early access: needs workflows on for the workspace. POST https://api.ken.so/v1/workflows/{workflowId}/runs
Path: workflowId
Body (json): estimateOnly boolean, records array
Start a live workflow on up to 1,000 records. Call with estimate_only=True first. Show the user the credits from the estimate before starting the runs.
POST /api/v1/workflows/{workflowId}/runs. Staff. Sends Ken-Version 1.1.
Requires workflows edit. Runs the published version; a workflow that is
not live answers 409 invalid_state.
records: 1 to 1000 {"type": "account"|"person"|"lead"|"place", "id":
<positive id, or the place's "plc_<id>">} objects, each once, of the type
the workflow's trigger runs on. Place records need the search_places
feature on the workspace.
estimate_only: return only the estimate and start nothing. Always call it
with estimate_only=True first and show the user expectedCredits and
maxCredits.
Returns {data: {estimate, estimateOnly, started, deduplicated, overLimit,
failed, results}}. estimate is {records, expectedMillicredits,
maxMillicredits, expectedCredits, maxCredits, steps}. results has one
{recordType, recordId, recordWireId, status, runId} per record in request
order; recordWireId is the id as sent (plc_7 for a place); status
is started, deduplicated (a run for that record already exists), over_limit
(the workflow's limits stopped it), not_live, not_found or failed. Follow
the runs with workflow_runs(operation="list"). A run that reaches
send.email@1, send.linkedin@1 or send.whatsapp@1 waits until a person
approves the touch (Ken approves a LinkedIn or WhatsApp send on auto) and
the Accounts send pass (DEV-1618) sends it, where sending is on for the
workspace, for up to the 14-day wait timeout. send.facebook@1 and
send.instagram@1 wait the same way.
set-step-output
Write. Early access: needs workflows on for the workspace. POST https://api.ken.so/v1/workflow-runs/{runId}/steps/{nodeId}/output
Path: runId, nodeId
Body (json): output object
Give one stuck step of a run its output by hand: it ends as succeeded and the run continues with that output. Nothing is run or charged. Save to field mappings of the step do not run for a hand-entered output.
POST /api/v1/workflow-runs/{runId}/steps/{nodeId}/output with body
{"output": <json>}. Staff. Sends Ken-Version 1.1. Requires workflows edit.
Returns the run with its step trace (as workflow_run_get).
Same rules as workflow_run_skip_step (which steps and runs qualify, the
409 and 400 answers), but the step ends as succeeded with output as its
output, error_class and error_message cleared and its credits unchanged.
Later steps read it like a real output ({{qualify.score}} is the score of
the output you gave). output is any JSON value except null, at most 256 KB
serialized: null answers 400 validation_failed (detail output, required),
an oversized value 400 (detail output, too_large). The output must match the
step type's output schema (workflow_steps describes it), and for ai.prompt
and code.run also the step's own outputSchema (an ai.prompt without one
answers {"text": "..."}): a mismatch answers 400 validation_failed with one
detail per problem, code schema_mismatch and field the path in the output
(output.score), and nothing changes. The step's Save to field mappings do
not run for a hand-entered output: set those fields yourself.
Example: run_id=5531, node_id="qualify", output={"score": 80}
skip-step
Write. Early access: needs workflows on for the workspace. POST https://api.ken.so/v1/workflow-runs/{runId}/steps/{nodeId}/skip
Path: runId, nodeId
Skip one stuck step of a run by hand: it ends as failed_safely and the run continues past it. The step keeps its error in the trace; later steps see its output as nulls.
POST /api/v1/workflow-runs/{runId}/steps/{nodeId}/skip. Staff. Sends
Ken-Version 1.1. Requires workflows edit. Returns the run with its step
trace (as workflow_run_get), after the engine planned what follows.
For a run in needs_attention or failed (also running or waiting): the
top-level step node_id, while it is queued (parked on a retry, a setup or a
budget hold), waiting, running or failed, becomes failed_safely with its
error_class and error_message kept, its queue item and waits are dropped,
and the run goes back to running. Downstream steps are planned as after an
onFailure continue. On a failed run the steps its failure cancelled run
again. Only a top-level step can be skipped: a step inside a for-each
answers 409 invalid_state (skip the for-each step instead), as does a step
that is already succeeded, failed_safely, skipped or cancelled, a step that
has not run yet, and a run that is queued, succeeded, cancelled or
over_limit. An unknown node_id answers 400 with error.details[0].code
unknown_node. To skip the same step in many runs use workflow_runs_bulk
with action="skip".
Example: run_id=5531, node_id="email"
step-overview
Read. Early access: needs workflows on for the workspace. GET https://api.ken.so/v1/workflow-runs/step-overview
Query: createdAfter date-time, createdBefore date-time, isTest boolean, workflowId integer
Per-step totals of one workflow's runs: status counts, average duration, credits and the latest error. Use it to find the step where runs fail or stall.
GET /api/v1/workflow-runs/step-overview. Staff. Sends Ken-Version 1.1.
Requires workflows view. 404 not_found for a workflow outside the workspace.
Covers the runs of workflow_id created in [created_after, created_before)
(ISO-8601; default the last 30 days ending now; at most 400 days).
is_test: only test runs (true) or only real runs (false).
Returns {data: {workflowId, from, to, runs, nodes: [{nodeId, stepType,
queued, running, waiting, succeeded, failed, failedSafely, skipped,
cancelled, avgDurationSeconds, creditsMillicredits, lastErrorClass,
lastErrorMessage, lastErrorAt}], sources: [{sourceId, triggerType,
runCount, lastRunAt, status, nextCheckAt, error, stoppedAt}]}}. runs
counts the runs in the window; nodes come in the order the steps first
ran; avgDurationSeconds is over the succeeded step runs. sources: per data
source, the runs it started in the window (one per record it matched),
its registration status (active, or failed with error and stoppedAt) and,
for a source read on a schedule or polled by Kenso (new leads, CRM list,
Places, Sales Navigator, LinkedIn signals), nextCheckAt.
browser-runs-summary
Read. Early access: needs browser_steps, workflows on for the workspace. GET https://api.ken.so/v1/browser-runs/summary
Query: createdAfter date-time, createdBefore date-time, nodeId string, workflowId integer (required)
Count one workflow's browser runs by status and bucket how fast the site's people replied after a submit. "23 of 40 took over a day": runs, byStatus and the reply buckets of a browser step.
GET /api/v1/browser-runs/summary. Staff. Sends Ken-Version 1.1. Requires
workflows view. Returns 404 not_found unless the workspace has the
workflows and browser_steps features on, and for a workflow of another
workspace.
Over the browser runs of workflow_id (one step with node_id) created in
[created_after, created_before) (ISO-8601; default the last 30 days, at
most 400 days).
Returns {data: {workflowId, nodeId, from, to, runs, byStatus {<status>:
count}, replies {withinHour, withinDay, afterDay, noneBeforeTimeout,
watching}, creditsMillicredits, credits, browserMinutes}}. The reply
buckets count the first human (not automated) reply from the site's domains
after each submit; noneBeforeTimeout are submitted runs whose watch closed
with no human reply, watching those still open.
Before the backend ships the route this returns success false with
error.code not_available.
Example: workflow_id=500, node_id="test"
revivals-summary
Read. Early access: needs lead_revival, workflows on for the workspace. GET https://api.ken.so/v1/revivals/summary
Query: createdAfter date-time, workflowId integer
Count the workspace's revivals by status and compare revived leads with the 10% holdout. Waiting, drafted, revived, replied, meetings booked and skipped by reason, with what each group did afterwards.
GET /api/v1/revivals/summary. Staff. Sends Ken-Version 1.1. Requires
workflows view. Returns 404 not_found unless the workspace has the
workflows and lead_revival features on.
Over the revival runs created at or after created_after (ISO-8601, default
365 days ago; not in the future), optionally of one workflow_id.
Returns {data: {waiting, drafted, revived, replied, meetingsBooked, skipped
({reason: count}, unknown when the reason is gone), cancelled, expired,
failed, comparison: {revived: {leads, replied, meetingsBooked, complaints},
holdout: {leads, replied, meetingsBooked, complaints}}, truncated}}.
truncated is true when more than 20,000 runs matched: the counts then
cover the newest 20,000 (narrow created_after or pass workflow_id). The comparison
counts distinct leads: revived are those whose revival was sent, with what
they did after the send; holdout are those the check held out, with what
they did after the check without a revival. replied is a human reply,
complaints an unsubscribe or a spam complaint.
Before the backend ships the route this returns success false with
error.code not_available.
Example: workflow_id=12