Step types

Each step does one job. Configure steps on the workflow canvas, or send the same parameters object to the workflow API. Parameter names are snake_case.

How steps return data

A step's output is saved under its key, so a step with key find_orders is read with {{ $anythink.steps.find_orders… }}. Where the output lives depends on the step:

When a step fails, its error details are saved at the top level of its output, and the workflow follows the step's on failure link if it has one.

Filters in data steps

Read data, Update data and Delete data select records with filter_conditions, a list of conditions that must all match:

[
  { "field": "status", "operator": "eq", "value": "pending" },
  { "field": "created_at", "operator": "lt", "value": "{{ $anythink.now }}" }
]

value can contain templates.

Warning: Operators other than these are ignored rather than rejected. For a Delete data step, a filter whose operators are all misspelled matches every record. Test delete steps against a copy of your data first.

Note: Values are added to the query as they are. Avoid values containing & in filters until this is handled.

Row-level security options

Steps run as the workflow worker, so records they create have no owner and aren't readable by users on entities with row-level security. Create data, Update data and Upsert data can grant access as part of the write:

A payload can also carry grants directly:

{
  "title": "Weekly check-in",
  "user_id": 21,
  "_rls": { "mode": "add", "users": [{ "user_id": 21, "readonly": false }] }
}

If a field named for grants is missing or can't be read, the step logs a warning and writes the record without that grant.

Limit: Update data ignores the row-level security options when it updates by ids. Use filters, or an _rls payload, to change grants.

Read data

Reads records from an entity.

Limit: Omitting limit currently fails validation with "Limit must be greater than or equal to 0" instead of falling back to 5000. Set limit explicitly until this is fixed.

Limit: anythink workflows step-add and step-update both silently rewrite a Read data step's entity parameter to entity_name, which then fails with "Entity is required". Neither CLI command can set a working Read data step yet — set parameters with a direct PUT /org/{orgId}/workflows/{workflowId}/steps/{stepId} call instead, until this is fixed.

Returns data: the list of records.

{
  "entity": "orders",
  "filter_conditions": [{ "field": "status", "operator": "eq", "value": "pending" }],
  "sort_by": "created_at",
  "sort_direction": "asc",
  "limit": 100
}

Reads ignore row-level security. Filter to the records the workflow should act on.

Create data

Creates one record, or one record per item in a list.

Returns data: the created records, or an empty list if every item was a duplicate. Fails when loop_over doesn't resolve to a list or a create fails.

{
  "entity_name": "order_reviews",
  "loop_over": "{{ $anythink.steps.large_orders.data }}",
  "payload": "{ \"order_id\": \"{{ id }}\", \"note\": \"Review orders over £100\" }",
  "prevent_duplicates": true
}

Update data

Updates records by id or by filter.

Returns data: the payloads that were sent (not the saved records). Fails when ids resolves to no numbers, or when neither ids nor filters are set.

{
  "entity_name": "orders",
  "ids": "{{ $anythink.trigger.id }}",
  "payload": "{ \"status\": \"reviewed\", \"reviewed_at\": \"{{ $anythink.now }}\" }"
}

Upsert data

For each item, finds a matching record by key fields, then updates it, leaves it, or creates a new one. Use it for imports and enrichment, where the same data may arrive more than once.

Returns data: one record per item, in the order of the input. Fails when an item is missing a match_on field.

When more than one record matches, the oldest (lowest id) is used and a warning is logged. Items are processed one at a time; if one fails, earlier items stay written.

{
  "entity_name": "customers",
  "loop_over": "{{ $anythink.steps.fetch_customers.data }}",
  "payload": "{ \"external_id\": \"{{ id }}\", \"email\": \"{{ email }}\", \"name\": \"{{ name }}\" }",
  "match_on": ["external_id"],
  "on_match": "Update",
  "update_fields": ["email", "name"]
}

Delete data

Deletes every record matching the filter.

Returns nothing, so later steps can't reference it. All matching ids are collected first and then deleted.

{
  "entity_name": "sessions",
  "filter_conditions": [{ "field": "expires_at", "operator": "lt", "value": "{{ $anythink.now }}" }]
}

Condition

Branches the workflow. When the conditions hold, the workflow follows on success; otherwise it follows on failure.

Text compares without regard to case. gt, gte, lt and lte compare as numbers when both sides are numbers.

Returns condition_result, logical_operator and evaluation_details, which lists each comparison with its actual value — useful when a branch goes the wrong way.

{
  "logical_operator": "AND",
  "filter_conditions": [
    { "field": "$anythink.trigger.data.total", "operator": "gte", "value": "100" }
  ]
}

Note: A false result with no on failure link ends the job as Failed. When "nothing to do" is normal, link the false branch to a harmless step.

Limit: is_null and is_not_null don't work reliably in conditions yet, because missing values are compared as text. Compare with eq and an empty value, or test for emptiness in Run a script.

Run a script

Runs JavaScript for logic that the other steps can't express: reshaping data, calculations, building prompts, parsing responses.

The script can read a $anythink object:

console.log, info, warn, error and debug write to the step's log. isArray, isObject and deepClone are available as helpers.

var orders = $anythink.steps.find_orders.data;
var total = orders.reduce(function (sum, o) { return sum + o.total; }, 0);
return { count: orders.length, total: total, over_budget: total > 5000 };

Scripts run on the Jint JavaScript interpreter with a 30-second timeout, 64 MB of memory and 100,000 statements. They have no network or file access, templates aren't applied inside scripts, and secrets aren't available — use Call an API or Integration for anything external.

Call an API

Sends an HTTP request.

Returns data: the parsed JSON response, or the part at results_path. Fails on a non-2xx status, with status_code and response in the output.

{
  "url": "https://api.example.com/v1/customers?updated_since={{ $anythink.steps.last_sync.data[0].synced_at }}",
  "method": "GET",
  "headers": { "Authorization": "Bearer {{ $anythink.secrets.example_api_key }}" },
  "results_path": "customers"
}

Note: An empty response stores no output. A response that isn't JSON, or a results_path that isn't found, succeeds with data set to {} — check the result in a Condition when it matters.

Note: Put credentials in headers, not in the URL. Request URLs are written to the step log.

Send an email

Sends one of your project's email templates. See Email templates.

Returns to, template_type, variables and attachment_count. Success means the email was queued for sending, not that it was delivered.

{
  "to": "{{ $anythink.trigger.data.email }}",
  "template_type": "welcome",
  "payload": "{ \"first_name\": \"{{ $anythink.trigger.data.first_name }}\" }"
}

Send a push notification

Sends a push notification through your configured providers and waits up to 30 seconds for the delivery result.

Send once per row. When the title, body or another content field refers to $anythink.steps.<key>.data[*], the step sends one notification per item in that step's data, with the item's fields available by name. Up to 10 send at once.

{
  "title": "{{ $anythink.steps.due_checkins.data[*].first_name }}, time for your check-in",
  "body": "It takes two minutes.",
  "audience": { "kind": "user", "user_id": "{{ $anythink.steps.due_checkins.data[*].user_id }}" }
}

Returns send_log_id, delivery_status, delivered, failed and unregistered; per-row sends return iterations and totals. The step fails if delivery fails — for per-row sends, only if every send fails.

File handler

Moves files in and out of records.

Downloads are limited to 50 MB and 30 seconds, and private or local network addresses are refused.

Returns file_id, url, mime_type, size_bytes and skipped, which is true when an existing file was kept.

{
  "operation": "FetchAndLink",
  "entity_name": "products",
  "record_id": "{{ $anythink.trigger.id }}",
  "field_name": "image",
  "source_url": "{{ $anythink.trigger.data.image_url }}",
  "skip_if_empty_source_url": true
}

Integration

Calls a connected service with your project's or a user's credentials. Connect services in Settings › Integrations.

Returns the service's result at the top level. AI text operations return text, model, input_tokens and output_tokens, read with {{ $anythink.steps.<key>.text }}.

{
  "provider": "claude",
  "operation": "generate-text",
  "credential_source": "system",
  "inputs": {
    "model": "claude-opus-4-8",
    "max_tokens": "2000",
    "system_prompt": "Summarise customer feedback in two sentences.",
    "prompt": "{{ $anythink.trigger.data.feedback }}"
  }
}

Limit: Claude models that start their reply with a thinking block, including Claude Opus 5, currently return empty text. Use claude-opus-4-8 until support lands. With no credentials connected, the step fails and tells you which service to connect.

Next steps