Automations error codes

Error codes emitted by Automations. Each code links to its own page with the cause and the action to take.

Code	Type	HTTP	Description
`automation_action_order_invalid`	`invalid_request_error`	422	The position of a step inside the sequence is not a whole number, or it is negative. That position is what fixes the order in which the actions run.
`automation_action_parameter_missing`	`invalid_request_error`	422	A parameter the action declares as required did not arrive. It is rejected here, rather than filled in with a default inside the adapter, so that a dry run predicts the real execution.
`automation_action_parameter_unknown`	`invalid_request_error`	422	A parameter key does not belong to the schema of the action. Accepting it would store a setting no adapter reads, and you would believe it active until the rule fired and did something else.
`automation_action_parameter_value_invalid`	`invalid_request_error`	422	A parameter of the action carries a value outside the set its schema accepts.
`automation_action_parameters_invalid`	`invalid_request_error`	422	The parameters of an action do not hold as a set: a value is not serialisable, a key is not text, two mutually exclusive parameters arrived together, or a pair that requires one of the two arrived with neither.
`automation_action_type_invalid`	`invalid_request_error`	422	One of the steps declares an action type with no adapter behind it, so nothing would run at that position.
`automation_chain_depth_exceeded`	`invalid_request_error`	422	One automation fired another until the chaining margin ran out, so the run stops before queueing any step. Waiting does not fix it: the same event would walk the same chain again.
`automation_condition_combinator_invalid`	`invalid_request_error`	422	A branch of the condition declares a logical combinator outside the accepted set, so the branch cannot be read as an "and" or as an "or".
`automation_condition_depth_exceeded`	`invalid_request_error`	422	The condition nests more levels than the evaluator walks, so the rule cannot be evaluated end to end.
`automation_condition_expression_invalid`	`invalid_request_error`	422	The shape of the condition tree does not hold: a malformed node, an operator receiving the wrong kind of value, a field path that is not a dotted route, or a tree past the limit of depth or of nodes.
`automation_condition_field_not_evaluable`	`invalid_request_error`	422	The condition reads a field the trigger does not publish as evaluable. The allowlist never resolves an unknown path to a default value, because a field resolved in silence is the very hole the sandbox exists to close.
`automation_condition_operator_invalid`	`invalid_request_error`	422	A comparison of the condition names an operator outside the accepted set.
`automation_condition_operator_not_applicable`	`invalid_request_error`	422	The operator does not apply to the type of the field it compares: asking whether one piece of text is greater than another is not a comparison the evaluator can make.
`automation_condition_operator_unsupported`	`invalid_request_error`	422	The evaluator has no implementation for that operator, so it stops instead of answering "false": a silent "false" would make "the condition does not match" indistinguishable from "it cannot be evaluated".
`automation_condition_payload_field_missing`	`invalid_request_error`	422	The key the condition reads is absent from the payload of the event, which is not the same as being present with a null value. Some events carry a reduced payload — a deletion, for instance, may only keep the identifier.
`automation_condition_payload_type_mismatch`	`invalid_request_error`	422	The value in the event contradicts the type the trigger declares for that field, and the evaluator does not convert types: a converted comparison would give a right answer by accident and hide that the payload changed shape.
`automation_dry_run_event_type_mismatch`	`invalid_request_error`	422	The dry run was asked with an event type other than the trigger of the rule being rehearsed, and a rule only ever receives events of its own trigger. The prediction would describe a delivery that is never going to happen.
`automation_event_company_unresolvable`	`invalid_request_error`	422	The event reached the engine without a company that could be resolved, and the engine stops rather than guessing one: writing a run under a substituted company would break the isolation between companies.
`automation_event_payload_not_resolvable`	`invalid_request_error`	422	The content of the event could not be recovered, so there is no payload to freeze into the run. It happens when the resource behind the event is no longer readable at the moment of delivery.
`automation_monthly_budget_exhausted`	`payment_required_error`	402	The company used up the automation runs its plan includes for the current period, so the run stops before queueing any step. Unlike a rate limit, waiting a few seconds changes nothing: what ran out is the budget of the cycle.
`automation_portfolio_scope_forbids_action`	`invalid_request_error`	422	One of the actions acts on the data of a single company, and under portfolio scope every run has a different managed company as its subject. Only actions that notify the managing company, or that touch no document at all, are admitted.
`automation_portfolio_scope_not_available`	`authorization_error`	403	This company cannot create automations over a portfolio: either it has no accounting-practice module, or it is itself a company managed by another one, and the relationship is only one level deep.
`automation_rate_limit_exceeded`	`rate_limit_error`	429	The company went over the automation runs its plan admits inside the limiter window. The work is admissible; it simply arrived too fast.
`automation_replay_not_allowed`	`invalid_request_error`	422	The run exists and is yours, but relaunching it does not apply: it has not finished yet, it finished well and its effect already happened, its outcome would take exactly the same branch again, or no outcome was recorded for it.
`automation_rule_actions_empty`	`invalid_request_error`	422	The rule declares no actions, so there would be nothing to run when its trigger fired.
`automation_rule_actions_limit_exceeded`	`invalid_request_error`	422	The rule contains more than 50 actions. One triggering event would therefore fan out into too many steps, queued jobs, and possible external effects.
`automation_rule_already_deleted`	`invalid_request_error`	422	The rule had already been taken down. Removal is logical and does not succeed in silence the second time, so two different removals never get confused with one another.
`automation_rule_company_mismatch`	`invalid_request_error`	422	The rule that was about to be materialised does not belong to the company of the event, so the run is not created: freezing the snapshot of an event — client, amounts, tax id — onto rows of another company is never allowed.
`automation_rule_name_invalid`	`invalid_request_error`	422	The name is empty or longer than the limit. The name is what identifies the rule in listings and in the history of its runs.
`automation_rule_not_found`	`not_found_error`	404	No automation rule with that identifier exists for the authenticated company. A rule that belongs to another company answers exactly the same way, so the response never reveals whether it exists elsewhere.
`automation_rule_scope_immutable`	`invalid_request_error`	422	The request tries to change the scope of an automation that already exists. Scope is fixed at creation because it decides whose events the rule observes, and changing it would reinterpret every run it has recorded so far.
`automation_rule_scope_invalid`	`invalid_request_error`	422	The scope you sent is not in the automation catalogue. There are only two: the company that creates the rule, and the portfolio of companies it manages.
`automation_rule_status_transition_invalid`	`invalid_request_error`	422	The rule cannot move from its current state to the one you asked for: activating, pausing and taking down each accept their own origin states.
`automation_rule_uuid_invalid`	`invalid_request_error`	422	The identifier is not a valid UUID v7. Automations address their resources by the `id` the API returns, never by an internal number.
`automation_rule_version_not_found`	`not_found_error`	404	The rule exists, but it has no version with that number: every save publishes a new version and the numbering never reuses a value.
`automation_rule_version_number_invalid`	`invalid_request_error`	422	The version number is below 1. Versions are numbered from one upwards, in the order they were published.
`automation_rule_version_snapshot_not_found`	`not_found_error`	404	The run points at a rule version whose frozen definition is not stored, so there is no definition to execute: a run always executes the version it started with, never the live rule.
`automation_run_not_found`	`not_found_error`	404	No automation run with that identifier exists for the authenticated company. A run of another company answers exactly the same way, so the response never reveals whether it exists elsewhere.
`automation_run_status_transition_invalid`	`invalid_request_error`	422	The run cannot move from its current state to the one requested: the life cycle of a run only admits the transitions its state declares.
`automation_run_step_not_found`	`not_found_error`	404	The run exists and belongs to you, but it has no step at that index. A run materialises every one of its steps when it starts, and the count never changes afterwards.
`automation_run_uuid_invalid`	`invalid_request_error`	422	The run identifier is not a valid UUID v7.
`automation_step_index_invalid`	`invalid_request_error`	422	A step index cannot be negative: no run addresses a step that way.
`automation_step_status_transition_invalid`	`invalid_request_error`	422	The step cannot move from its current state to the one requested. It is what stops a finished step from being claimed twice, and that guard is what makes a replay produce each effect only once.
`automation_step_subject_company_mismatch`	`invalid_request_error`	422	The item the action was about to act on does not belong to the company of the run, or its company could not be determined. Either way the step aborts before the adapter is invoked, so no effect is produced.
`automation_subject_company_ownership_not_verified`	`invalid_request_error`	422	While preparing the run it could not be proven that the company behind the event is still an active managed company of whoever created the automation. The link may have been archived, the company deactivated, or the run reached this point with mismatched data.
`automation_trigger_not_found`	`not_found_error`	404	The trigger is not in the catalogue your company can see. A name that does not exist and a real trigger whose module your company has not been granted answer the same, so the response never confirms which of the two it is.
`automation_trigger_payload_contract_unknown`	`invalid_request_error`	422	The trigger publishes no contract of evaluable fields, so there is no catalogue against which to resolve a condition.
`automation_trigger_type_invalid`	`invalid_request_error`	422	The write carries a trigger that is not in the catalogue available to your company, so the rule would never receive an event.

Error codes by category

Find an error by the category that emits it.

Full reference table

All codes, HTTP statuses, types and descriptions in one reference.

Error model

Interpret the error envelope and handle errors by code.

Related

On this page