Flow API: basics

SENSEVER

The official Sensever channel: guides and API documentation for Chat, Requests, Flow, Studio, bots and messaging channels.

22 मिनट का पाठ

Flow API: basics

The Flow API is the HTTP interface your server uses to work with Flow data: read and create objects, move them through statuses, run queries, and configure types, automations, processes and webhooks. It is the same API the Flow interface on sensever.com uses: anything a person does in the interface, a program does with the same requests and the same permissions.

This article covers the general rules: base URLs, authorization, headers, errors, limits, pagination and the full list of methods. For a step-by-step example, see Flow API: your first integration in 15 minutes. Workspaces, types and statuses are explained in Flow: introduction.

Base URLs

API

Base URL

What is available

Flow API

https://flow.sensever.com/v1

The full contract: objects, schema, views, automations, processes, webhooks, reports, access

Flow API via the unified Sensever API

https://api.sensever.com/v1/flow

The same contract and the same key; paths are the same as for https://flow.sensever.com/v1

Legacy gateway (deprecated)

https://sensever.com/api/v1/flow, https://api.sensever.com/v1/chat/flow

A limited set of methods (see below). Shuts down on October 13, 2026

All requests must use HTTPS. Paths in the "Flow API" articles are relative to the base URL: POST /objects means POST https://flow.sensever.com/v1/objects.

For integrations, use https://flow.sensever.com/v1 or https://api.sensever.com/v1/flow. The legacy gateway is kept for compatibility only: it forwards a subset of methods to Flow and returns its own rejections as errors in the unified Sensever API format. Its responses carry the headers Deprecation: true, Sunset: Tue, 13 Oct 2026 00:00:00 GMT and Link: <https://api.sensever.com/v1/flow/…>; rel="successor-version" — the replacement URL with the same path.

Migrating from the legacy gateway

Replace the beginning of the URL; everything else stays the same — the key, X-Workspace-Id, the body and the path:

Before

After

https://sensever.com/api/v1/flow/objects/query

https://api.sensever.com/v1/flow/objects/query

https://api.sensever.com/v1/chat/flow/objects/{uuid}

https://api.sensever.com/v1/flow/objects/{uuid}

After October 13, 2026, the old URLs may be shut down without further notice.

What the legacy gateway sensever.com/api/v1/flow forwards

Method

Paths (relative to /api/v1/flow)

GET

/me, /workspace, /object-types, /object-types/{uuid}, /object-types/{uuid}/lifecycle, /schema-versions/{uuid}, /lifecycle-versions/{uuid}, /objects/{uuid}, /objects/{uuid}/history, /views/{uuid}

POST

/objects, /objects/query, /objects/available-actions, /objects/{uuid}/archive, /objects/{uuid}/restore, /objects/{uuid}/transitions/{key}

PATCH

/objects/{uuid}

Gateway specifics:

  • the type in the path must be a UUID; the gateway does not accept a type key (task);

  • no more than 120 requests per minute;

  • only the headers X-Workspace-Id, Idempotency-Key, If-Match and X-Request-ID are passed to Flow; Flow does not use If-Match — the object version goes in the expected_version body field;

  • the gateway itself answers 403 forbidden to a key without Flow access, a read-only key on a write request, and a workspace not in the key; a path outside the list gets 404 not_found; a failure or a 5xx from Flow gets 503 dependency_unavailable. All other Flow responses are passed through as is;

  • GET /me through the gateway works only in a person's session: an API key gets 401 (see Flow API: workspace, access and notifications).

Authorization

API key from your Sensever profile

The main option for integrations is a Sensever platform key. A person issues it in their profile on sensever.com: Profile → API (https://sensever.com/profile/api), the "API keys" form:

  1. "Key name" — for example, "Company website".

  2. In the Flow block, choose the access level: "No access to Flow", "Read-only" (objects, types and views of the selected workspaces) or "Read and write" (creating and changing objects, status transitions).

  3. Select the Flow workspaces the key will work in. A key with Flow access cannot be created without at least one selected workspace.

  4. "Expiration": 30, 90 (default), 180 or 365 days, or "No expiration" — until revoked.

  5. "Create key". The full key is shown only once — copy it right away.

The same key can also carry chat and publishing permissions — one key works across all Sensever products. You can revoke a key in the same place with the "Revoke" button.

Pass the key in a header together with the workspace:

Authorization: Bearer ak1.XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
X-Workspace-Id: 0190f3c2-7d4e-7a31-9b1f-5c2d8e4a6b70

How the key works:

  • The key acts on behalf of the person who issued it. In Flow it gets exactly that person's permissions as a workspace member, never more.

  • X-Workspace-Id is required and must be one of the workspaces selected in the key. You can find the workspace UUID in the Flow interface URL: https://sensever.com/flow/w/<workspace UUID>/….

  • A "Read-only" key allows any GET and two queries — POST /objects/query and POST /objects/available-actions. Everything else gets 403, including requests that only read data but are sent with POST: running a view POST /views/{id}/query, reports POST /reports/…, batch reads POST /objects/relations, POST /objects/subtask-progress, POST /time/totals, POST /recurrence/lookup and recurrence preview. These need a "Read and write" key.

  • The key does not depend on the session it was created in: signing out of Sensever, changing your password or "sign out everywhere" do not stop it. The key stops working when it is revoked, when it expires, or when the Sensever account is disabled.

  • Flow verifies the key with Sensever Accounts and caches the answer for 60 seconds, so revoking a key reaches Flow within a minute.

  • Store the key on your server only. Never put it into HTML, browser JavaScript, a mobile build or a public repository.

Key-related rejections (403 PERMISSION_DENIED, the reason is in error.details.reason):

details.reason

Meaning

key_without_flow

The key has "No access to Flow" selected

workspace_not_in_key

The workspace from X-Workspace-Id is not in the key

read_only_key

The key is "Read-only", but the request changes something

not_a_member

The key owner is not a member of this workspace or has never signed in to Flow

principal_disabled

The member is disabled in the workspace

account_disabled

The key owner's Sensever account is disabled

key_scope

A workspace key (flw_…) with restricted scopes does not allow this action

Without X-Workspace-Id, a request with a platform key gets 422 VALIDATION_FAILED with the field header.X-Workspace-Id. An invalid, revoked or expired key gets 401 UNAUTHENTICATED. If Flow cannot verify the key because Accounts is down, the response is 503 SERVICE_UNAVAILABLE (retry later), not 401.

Workspace key flw_…

A workspace also has its own service keys of the form flw_<prefix>_<secret>. A member with the integration.manage permission issues them with POST /api-credentials; they are not available in the Flow interface. Such a key is bound to one workspace: X-Workspace-Id is not needed with it and is ignored. You can narrow the key's permissions with scopes (scopes), for example object:read or object:*. Details are in Flow API: workspace, access and notifications.

A member's keys are revoked automatically when the member is disabled or removed from the workspace.

Key scopes

A scope is a resource:action pair taken from role permissions, for example object:read, object:update, schema:manage. A method requires the same permissions a person needs in the interface, so a key with scopes needs the scopes for those permissions. For methods added since 25.09:

Methods

Required scopes

GET /objects/{id}/mention-candidates, GET /object-types/{type}/mention-candidates, POST /objects/relations, POST /objects/subtask-progress, GET /objects/{id}/recurrence, POST /objects/{id}/recurrence/preview, POST /recurrence/lookup, GET /objects/{id}/time, POST /time/totals, POST /reports/time, GET /reports/time/export

object:read

GET /object-types/{type}/fields/{field}/tags

object:read and field:read

POST /objects/{id}/discussion/mentions, PUT and DELETE /objects/{id}/recurrence, POST /objects/{id}/time, POST /time/timer, PATCH and DELETE /time-entries/{id} for your own entry

object:update

POST /objects/{id}/checklists/{field}

object:update and field:update

Another member's time (principal_id in POST /objects/{id}/time), editing and deleting other people's time entries

workspace:manage

POST /operations of kind bulk_transition

transition:execute

GET /type-presets

schema:read

POST /object-types/{type}/subtasks, GET /templates/file

schema:manage

POST /type-presets/{key}/apply, POST /templates/file/apply

schema:manage, plus the permissions of the preset's steps: view:manage, automation:manage, process:manage

A missing scope gets 403 PERMISSION_DENIED with details.reason = key_scope.

What is not suitable for integrations

The browser session (the flow_session cookie) and the embed token (a JWT that sensever.com obtains for its own Flow interface) are how the interface itself signs in. The embed token lives for 10 minutes and is issued only to the sensever.com server. Integrations do not use them.

Some methods work only with a session or an embed token — they concern a person across all of their workspaces at once, while a key is always bound to specific workspaces. An API key (both ak1.… and flw_…) gets 401 UNAUTHENTICATED on them; X-Workspace-Id is not needed and is ignored:

  • GET /me, POST /workspaces, GET /invitations, POST /invitations/{workspace}/{invitation}/respond;

  • everything under /me/…: POST /me/objects/query, POST /me/objects/calendar, GET /me/objects/filters, GET /me/approvals, POST /me/reports/summary, GET /me/tasks and the other "By section" methods, GET, POST, DELETE /me/calendar-feeds…, GET, PATCH /me/mail-settings.

An integration that needs data from several workspaces iterates over them itself with the appropriate X-Workspace-Id.

GET /calendar-feeds/{token} is the only public method apart from health checks: it returns a calendar in iCalendar format via a secret subscription link, with no session or key. Details are in Flow API: personal lists, calendar and email.

Headers

Header

Direction

Purpose

Authorization: Bearer …

request

API key (ak1.… or flw_…)

X-Workspace-Id

request

Workspace UUID. Required for a platform key, ignored for a flw_… key

Content-Type: application/json

request

The body is JSON in UTF-8 (except CSV uploads)

Idempotency-Key

request

Key for safely retrying a change, 8–255 visible ASCII characters

X-Request-Id

request and response

Your request ID (8–128 characters [A-Za-z0-9._:-]); without it, the server generates a UUIDv7. Always returned in the response and in error.request_id

Prefer: return=minimal

request

Compact response for commands that change definitions

Preference-Applied: return=minimal

response

The server applied Prefer: return=minimal

Idempotency-Replayed: true

response

The response is a replay of the stored response for the same Idempotency-Key

Retry-After

response

How many seconds to wait before retrying (429, 503)

X-Client

request

Client version <platform>/<version>, for example ios/2.4.0. Optional for integrations

Flow does not use ETag and If-Match: concurrent changes are protected by the expected_version field in the request body.

Idempotency-Key: safe retries

You can safely retry a write request after a network error if you send the same Idempotency-Key:

  • the key is stored for 24 hours and belongs to the caller; the first response is stored byte for byte and returned again with the Idempotency-Replayed: true header — including 4xx business errors, except 409 OBJECT_VERSION_CONFLICT and 429;

  • the same key with a different method, path, body or Prefer gets 422 IDEMPOTENCY_KEY_REUSED;

  • while the first request with this key is still running, a retry gets 409 IDEMPOTENCY_IN_PROGRESS;

  • 5xx responses are not stored: the change is rolled back, and a retry with the same key runs again from scratch.

The key is required for POST /objects, transitions POST /objects/{id}/transitions/{transition_key}, background operations POST /operations, starting a process POST /processes/{key}/start and external events POST /events. Without it you get 422 VALIDATION_FAILED with the field header.Idempotency-Key. For other changes the key is optional but recommended. Queries (POST /objects/query and similar) do not use the key.

Generate a new key (for example, a UUID) for each logical action and keep it until you get a response. Do not create a new key when retrying after a timeout — otherwise the object may be created twice.

expected_version: protection against concurrent changes

An object has a version number, version, which increases with every change. Changing an object (PATCH /objects/{id}) requires expected_version — the version you read. If the object has been changed in the meantime, the response is 409 OBJECT_VERSION_CONFLICT: re-read the object and apply your change to the new version. In a transition, expected_version is optional: without it, the current version is used.

Prefer: return=minimal

Commands that create and change definitions (schema and status process versions, views, automations, processes, roles — 21 methods) respond with the full definition by default. With the Prefer: return=minimal header, they return a compact DefinitionResult:

{
  "representation": "minimal",
  "resource": "schema_version",
  "id": "0190f3c2-7d4e-7a31-9b1f-5c2d8e4a6b70",
  "version": 3,
  "status": "draft",
  "href": "/v1/schema-versions/0190f3c2-7d4e-7a31-9b1f-5c2d8e4a6b70"
}

Read the full state with GET href. Even without Prefer, the server returns the compact result if the full definition is larger than 64 KB, so check the representation field before parsing the response. More in Flow API: types, fields, statuses and publishing.

Requests and responses

  • The request body is a JSON object. An unknown field in the body is usually rejected with 422 VALIDATION_FAILED, so do not send extra fields.

  • The response is JSON with status 200 or 201. Export returns a CSV file.

  • Time is an RFC 3339 string in UTC, for example 2026-09-25T08:00:00Z.

  • IDs of objects, types, versions and members are UUIDs (UUIDv7 for those created by the platform). Types, fields, statuses, transitions and actions also have a stable machine key (key, up to 64 characters), for example task, due_date, in_progress. Where a method accepts "a key or an id", you can pass either.

Compatibility

The API evolves only by additions within /v1: fields, values and methods are never removed or renamed without /v2. So your client must:

  • ignore unknown response fields;

  • handle unknown enum values (new statuses, reasons, kinds);

  • treat an unknown error.code as a generic error of its HTTP status.

Do not treat your own copies of business checks as final: the API always decides whether a transition is available and what is permitted. To show available transitions in advance, use GET /objects/{id}/available-actions.

Pagination

Lists are read with cursors (keyset). In the request, pass page.size from 1 to 200 (default 50) and page.cursor; in GET methods, use the parameters page[size] and page[cursor]. The response contains:

{
  "items": [],
  "page": { "size": 50, "next_cursor": "eyJ2Ijox…" }
}

Pass next_cursor as page.cursor to get the next page; null means the last page. The cursor is opaque: do not parse it or build it yourself. A cursor is valid only for the same query (same type, condition and sort); someone else's or a modified cursor gets 422 VALIDATION_FAILED with the field page.cursor.

Errors

Every error is JSON with a 4xx or 5xx HTTP status in a single envelope:

{
  "error": {
    "code": "VALIDATION_FAILED",
    "message": "Validation failed",
    "details": {
      "fields": [
        { "field": "fields.due_date", "code": "invalid_format", "messages": ["…"] }
      ]
    },
    "request_id": "0190f3c2-7d4e-7a31-9b1f-5c2d8e4a6b70"
  }
}

Your code should rely on error.code and error.details, not on message: the message is for logs and developers, and its text may change. details is an empty object if there are no details. For some codes, details is always present:

error.code

What is in details

VALIDATION_FAILED

fields[] — the field (a path, for example where.and[2].value or header.Idempotency-Key), code and messages

CONSTRAINT_VIOLATION

violations[] — the type rules that were violated

TRANSITION_NOT_ALLOWED

reasons[] — rejection reasons in the order of checks, required_fields, failed_guards, failed_constraints

LIMIT_EXCEEDED

limit and actual

PAYLOAD_TOO_LARGE

limit and actual in bytes, if the size is known

DEFINITION_INVALID

errors[] — definition errors found at publishing

details.fields contains at most the first 100 errors and at most 32 KB. If there are more errors, details has truncated: true and fields_total — the total number. Paths and messages longer than 1000 characters are truncated with an ellipsis.

Error codes

HTTP

error.code

Meaning and what to do

401

UNAUTHENTICATED

No key, or the key is invalid, revoked or expired

403

PERMISSION_DENIED

Insufficient permissions; the reason is in details.reason (see above)

403

FIELD_NOT_READABLE

A condition or sort on a field you are not allowed to read

404

NOT_FOUND

The resource does not exist or is not visible to you

404

OBJECT_NOT_FOUND

The object does not exist or is not visible to you

404

PROCESS_NOT_FOUND

The process does not exist

405

METHOD_NOT_ALLOWED

The method is not supported for this path

409

OBJECT_VERSION_CONFLICT

The object was changed after you read it: re-read and retry

409

OBJECT_ARCHIVED

The object is archived

409

OBJECT_TYPE_ARCHIVED

The object type is archived

409

RELATION_RESTRICT

A relation prevents the action

409

IDEMPOTENCY_IN_PROGRESS

A request with this Idempotency-Key is still running

409

DEFINITION_IMMUTABLE

A published definition version cannot be changed — create a draft

409

APPROVAL_ALREADY_DECIDED

The approval has already been decided

413

PAYLOAD_TOO_LARGE

The body exceeds the limit

422

VALIDATION_FAILED

Invalid parameters; details are in details.fields

422

LIMIT_EXCEEDED

A structural limit is exceeded (number of fields, relations, items)

422

IDEMPOTENCY_KEY_REUSED

The same Idempotency-Key with a different request

422

FIELD_READONLY

The field is read-only

422

FIELD_NOT_IN_SCHEMA_VERSION

The field is not in the object's schema version

422

STATUS_CHANGE_REQUIRES_TRANSITION

The status can only be changed by a transition

422

CONSTRAINT_VIOLATION

A type rule is violated

422

TRANSITION_NOT_ALLOWED

The transition is not available right now; reasons are in details.reasons

422

RELATION_CARDINALITY_VIOLATION

The allowed number of relations is violated

422

RELATION_CYCLE

The relation creates a cycle

422

RELATION_TYPE_MISMATCH

The object is not suitable for this relation

422

DEFINITION_INVALID

The definition fails the publishing check

422

EXPRESSION_TIME_PATTERN_UNSUPPORTED

Unsupported time pattern in an expression

422

RELATED_SET_TOO_LARGE

Too many related objects to check

422

QUERY_TOO_EXPENSIVE

The query is too expensive; the reason is in details.reason

422

INDEX_QUOTA_EXCEEDED

The field index quota is used up

422

FIELD_TYPE_NOT_INDEXABLE

Fields of this type cannot be indexed

422

MIGRATION_MAPPING_INCOMPLETE

When publishing a status process, you did not specify where to move objects from removed statuses

422

APPROVAL_NOT_ASSIGNED

The approval is not assigned to you

422

RUN_NOT_RETRYABLE

This automation run cannot be retried

422

EXTERNAL_EVENT_CONFLICT

An external event with the same key but different content

426

CLIENT_UPGRADE_REQUIRED

The client version in X-Client is below the supported one

429

RATE_LIMITED

The rate limit is exceeded; wait Retry-After seconds

500

INTERNAL

Internal error; the change was rolled back

503

SERVICE_UNAVAILABLE

Temporarily unavailable; retry after Retry-After

Other details.reason values for 403: csrf and session_revoked apply to the browser session and the embed token; integrations do not encounter them.

Retries

Retry the request after 429, 503, 500 and network errors — for changes, with the same Idempotency-Key. After 409 OBJECT_VERSION_CONFLICT, re-read the object first. Do not retry unchanged requests that got 401, 403, 404 or 422.

Limits

What

Limit

Requests per minute per workspace

6000

Requests per minute per member (key) in a workspace

1200

Requests per minute through the legacy gateway sensever.com/api/v1/flow (until 13.10.2026)

120

Request body

1 MB; 10 MB for bulk operations and import (413 PAYLOAD_TOO_LARGE)

Fields in one change (fields, set)

200

string / text field value

1 KB / 100 KB

json field value

64 KB

Items in a multi-value field

1000

Checklist (checklist)

100 items of 1–500 characters; 100 operations in POST /objects/{id}/checklists/{field}

Tags (tags)

20 tags of 1–50 characters

Relations when creating an object

100

Objects in a bulk request

1000

object_ids in POST /objects/available-actions, POST /objects/subtask-progress, POST /time/totals

200

object_ids in POST /objects/relations, POST /recurrence/lookup

500

Calendar downloads per subscription link

60 per hour

Query (Query AST)

32 KB

External event body POST /events

256 KB

Stored response for an Idempotency-Key

64 KB

Page size

1–200

Per-minute request limits are defaults; the workspace owner can change them with quotas (PATCH /workspace). When a limit is exceeded, you get 429 RATE_LIMITED and a Retry-After header. Structural limits return 422 LIMIT_EXCEEDED with details.limit and details.actual.

All methods

The service endpoints GET /health/live and GET /health/ready respond without authorization.

Objects

Details: Flow API: objects, transitions and relations.

Method

Request

Create an object

POST /objects

Read, update

GET /objects/{id}, PATCH /objects/{id}

Archive, restore

POST /objects/{id}/archive, POST /objects/{id}/restore

Run a transition

POST /objects/{id}/transitions/{transition_key}

Available actions

GET /objects/{id}/available-actions, POST /objects/available-actions

Run an object action

POST /objects/{id}/actions/{action_key}

History

GET /objects/{id}/history

Relations

GET, POST /objects/{id}/relations/{relation_key}, DELETE /objects/{id}/relations/{relation_key}/{object_id}

Relations of many objects

POST /objects/relations

Checklist items

POST /objects/{id}/checklists/{field}

Files

GET, POST /objects/{id}/attachments, POST /objects/{id}/attachments/uploads, GET /objects/{id}/attachments/{attachment_id}/download-url, DELETE /objects/{id}/attachments/{attachment_id}

Discussion in chat

POST /objects/{id}/discussion

Mentions

GET /objects/{id}/mention-candidates, GET /object-types/{type}/mention-candidates, POST /objects/{id}/discussion/mentions

Subtasks, checklists and recurrence

Details: Flow API: subtasks, checklists and recurrence.

Method

Request

Enable subtasks for a type

POST /object-types/{type}/subtasks

Subtask counters

POST /objects/subtask-progress

Checklist items

POST /objects/{id}/checklists/{field}

Object recurrence

GET, PUT, DELETE /objects/{id}/recurrence, POST /objects/{id}/recurrence/preview

Which objects recur

POST /recurrence/lookup

Time tracking

Details: Flow API: time tracking.

Method

Request

Object time

GET, POST /objects/{id}/time

Time entries

PATCH, DELETE /time-entries/{id}

Timer

GET, POST /time/timer, POST /time/timer/stop

Totals for a table column

POST /time/totals

"Time" report

POST /reports/time, GET /reports/time/export

Queries and search

Details: Flow API: query language and search.

Method

Request

Query objects of a type

POST /objects/query

Objects of all my workspaces (session only)

POST /me/objects/query

Field index

GET, POST, DELETE /fields/{id}/index

Full-text search language

GET, PUT /search/settings

Personal lists, calendar and email

Session or embed token only. Details: Flow API: personal lists, calendar and email.

Method

Request

"By section": my tasks across all workspaces

GET /me/tasks, GET /me/tasks/counts, PATCH /me/tasks/settings, PUT /me/tasks/sections/{section_id}/order

"All objects" as a calendar and filter options

POST /me/objects/calendar, GET /me/objects/filters

Calendar subscription links

GET, POST /me/calendar-feeds, DELETE /me/calendar-feeds/{id}

Calendar via a subscription link (public)

GET /calendar-feeds/{token}

Email settings

GET, PATCH /me/mail-settings

Types, fields, statuses and rules

Details: Flow API: types, fields, statuses and publishing.

Method

Request

Object types

GET, POST /object-types, GET, PATCH, DELETE /object-types/{type}, POST /object-types/{type}/archive

Type presets

GET /type-presets, POST /type-presets/{key}/apply

Template as a file

GET /templates/file, POST /templates/file/apply

Fields and schema versions

POST /object-types/{type}/fields, POST /object-types/{type}/schema-versions, GET, PATCH /schema-versions/{id}, POST /schema-versions/{id}/publish

Migrating objects to the current schema

GET, POST /object-types/{type}/schema-migration

Field tags

GET /object-types/{type}/fields/{field}/tags

Subtasks

POST /object-types/{type}/subtasks

Relation types

GET, POST /relation-types

Status process

GET /object-types/{type}/lifecycle, POST /object-types/{type}/lifecycle/versions, GET, PATCH /lifecycle-versions/{id}, POST /lifecycle-versions/{id}/publish

Rules (constraints)

GET, POST /object-types/{type}/constraints, GET, PATCH /constraint-versions/{id}, POST /constraint-versions/{id}/publish, PATCH /constraints/{id}

Object actions

GET, POST /object-types/{type}/actions, PATCH, DELETE /object-actions/{id}

Views, export, import, background operations

Details: Flow API: views, export, import and background operations.

Method

Request

Views

GET, POST /object-types/{type}/views, GET, PATCH, DELETE /views/{id}, POST /views/{id}/query

Export to CSV

GET /views/{id}/export, POST /objects/export

Uploading CSV for import

POST /import-files, GET /import-files/{id}

Background operations

POST /operations, GET /operations/{id}, GET /operations/{id}/errors

Automations and reminders

Details: Flow API: automations, reminders and expressions.

Method

Request

Automations

GET, POST /object-types/{type}/automations, GET, PATCH /automations/{id}

Automation versions

POST /automations/{id}/versions, GET, PATCH /automation-versions/{id}, POST /automation-versions/{id}/publish

Run log

GET /automation-runs, GET /automation-runs/{id}, POST /automation-runs/{id}/retry

Due date reminders

GET, POST /object-types/{type}/reminder-rules, PATCH, DELETE /reminder-rules/{id}

Processes, approvals, external events

Details: Flow API: processes, approvals and external events.

Method

Request

Processes

GET, POST /processes, GET /processes/{key}, POST /processes/{key}/versions, GET, PATCH /process-versions/{id}, POST /process-versions/{id}/publish

Start and instances

POST /processes/{key}/start, GET /process-instances, GET /process-instances/{id}, POST /process-instances/{id}/cancel

Approvals

GET /approvals, GET /approvals/{id}, POST /approvals/{id}/decision

Approvals across all my workspaces (session only)

GET /me/approvals

External event

POST /events

Webhooks

Details: Flow API: webhooks.

Method

Request

Subscriptions

GET, POST /webhook-subscriptions, PATCH, DELETE /webhook-subscriptions/{id}

Deliveries, secret, test

GET /webhook-subscriptions/{id}/deliveries, POST /webhook-subscriptions/{id}/rotate-secret, POST /webhook-subscriptions/{id}/test

Reports and business calendar

Details: Flow API: reports, SLA and business calendar.

Method

Request

Dashboard summaries

POST /reports/aggregate

Funnel and burndown

POST /reports/funnel, POST /reports/burndown

Dashboards

GET, POST /dashboards, GET, PATCH, DELETE /dashboards/{id}

Summary across all my workspaces (session only)

POST /me/reports/summary

Time in status

POST /reports/time-in-state, GET /reports/objects/{id}/time-in-state

SLA

POST /reports/sla, POST /reports/sla/breaches, GET /reports/objects/{id}/sla

Business calendar

GET, PUT /workspace/calendar

Workspace, access, notifications

Details: Flow API: workspace, access and notifications.

Method

Request

Workspace

GET, PATCH, DELETE /workspace

Me and my workspaces (session only)

GET /me, POST /workspaces

Members

GET /workspace/members, PATCH, DELETE /workspace/members/{principal_id}

Invitations

GET /workspace/people, GET, POST /workspace/invitations, DELETE /workspace/invitations/{invitation}

My invitations (session only)

GET /invitations, POST /invitations/{workspace}/{invitation}/respond

Roles and permissions

GET, POST /workspace/roles, GET, PATCH, DELETE /workspace/roles/{id}, PUT /workspace/roles/{id}/permissions

Teams

GET, POST /workspace/teams, PATCH, DELETE /workspace/teams/{id}, PUT /workspace/teams/{id}/members

Workspace keys

GET, POST /api-credentials, DELETE /api-credentials/{id}

My notifications

GET, PATCH /workspace/notification-settings

टिप्पणियाँ

लेखक