Skip to main content
PATCH
Update a table column

Authorizations

​
X-API-Key
string
header
required

Path Parameters

​
table_id
string<uuid>
required
​
column_id
string<uuid>
required

Body

application/json

Request body for updating a table column (tri-state PATCH semantics).

​
auto_run

Whether data changes recompute this column by themselves. Off, its cells go visibly stale and wait for an explicit run.

​
column_type

The type a user picks for a table column.

Ordered as the picker shows them, which is also the order the groups below run in: text-ish, then numeric, then choice, then structured.

Available options:
text,
paragraph,
url,
email,
image_url,
person,
select,
number,
decimal,
currency,
checkbox,
date,
multi_select,
list,
object
​
data_type

Type of a property. Used while creating/updating/deleting properties.

Available options:
string,
integer,
float,
boolean,
datetime,
date,
list,
dict
​
definition

Definition of a manual column: typed, user-editable cells.

​
description

New description. Set to null to clear.

Required string length: 1 - 2000
​
display_name
string
Required string length: 1 - 255
​
expand_output_fields
boolean
default:true

For a multi-field enrichment, keep the fan-out in step with the declared output: create one child column per scalar output field this edit ADDS (the same fan-out a column of the same shape gets when it is created), and DELETE the column of a field it REMOVES, along with that column's values. A removed field's column reads a key the answer no longer carries, so it could only ever sit empty. A field the column already declared is left alone, and a column another column depends on is kept rather than breaking it. Set false to change the output without touching any other column.

​
output_column_names
Output Column Names · object

What to CALL each child column this edit ADDS, keyed by output field name (the create request's field, read the same way). Without it a new child's header is derived from the field's key, which reads a hand-written name back as though it were one: a field called 'LinkedIn URL' becomes the column 'Linked In Url'. A field with no entry keeps the derived name, a name already taken on the table falls back to the derived one rather than losing the column, and a field this edit did not add is ignored. Ignored when expand_output_fields is false. Children that already exist are never renamed.

​
position
integer
Required range: x >= 0
​
refresh_interval_hours

New self re-run cadence in hours; 0 turns it off.

​
run_condition

Definition of a manual column: typed, user-editable cells.

​
run_condition_view_id

A saved view whose filter this column follows as its run condition, evaluated at run time so the gate tracks the view. Null detaches and goes back to running every row. Mutually exclusive with a non-null run_condition in the same request; omit it to leave the link alone.

​
run_delay_seconds

New pre-run wait in seconds; 0 runs immediately. Capped at 600.

​
suppress_run
boolean
default:false

Save the change without recomputing. The column's cells keep their current values and pending_recompute is set, so the staleness is recorded rather than hidden; run the column when you are ready. A plain bool, not tri-state: it instructs THIS request and has no 'leave unchanged' meaning to carry over.

​
type_options

Options for a single-select column.

Response

Successful Response

A column update result; the recompute run (if due) appears on the next poll.

​
cleared_count
integer
required

Values a type change could not convert into the new type and left blank; 0 when no value moved.

​
column_type
enum<string>
required

The semantic type; what the cell renders and validates as.

Available options:
text,
paragraph,
url,
email,
image_url,
person,
select,
number,
decimal,
currency,
checkbox,
date,
multi_select,
list,
object
​
created_at
string<date-time>
required
​
data_type
enum<string>
required

The storage type column_type resolves to, and so which typed value slot the cells live in. Derived, never chosen.

Available options:
string,
integer,
float,
boolean,
datetime,
date,
list,
dict
​
definition
ManualColumnDefinition · object
required

Definition of a manual column: typed, user-editable cells.

​
definition_version
integer
required

Bumped on definition changes; cosmetic edits leave it untouched.

​
depends_on_column_ids
string<uuid>[]
required

Direct chain inputs; empty for manual columns.

​
description
string | null
required

Author-written note on what the column holds; null when unset.

​
display_name
string
required
​
group_id
string<uuid> | null
required

The column group this column belongs to, or null. Groups are user-managed entities delivered on the column list's groups; this field is the membership edge, and the members' order is simply the columns' position order.

​
id
string<uuid>
required
​
is_group_output
boolean
required

Whether this member stays visible while its group is collapsed. Meaningful only while group_id is set. Every group keeps at least one output.

​
kind
enum<string>
required

Kind of a table column.

MANUAL cells are user-editable; FORMULA cells are a pure computed chain over other columns; ENRICHMENT cells are produced by an external action (an AI model, a research agent) run once per row. Formula and enrichment cells are both computed (read-only in the grid) but only enrichment work leaves the process and costs credits.

SOURCE cells hold one imported record verbatim, written only by the table's import source. Like MANUAL it is an externally-written leaf rather than a computed node (it joins no run plan and derives from no other column), but unlike MANUAL nobody may edit or retype it: the whole point is that a refresh can overwrite it wholesale, and every get_path column promoted off it reads paths that only survive while its shape does.

EXPORT cells hold the RECEIPT of pushing the row to a connected destination (status, the destination record id, when it happened), never the row's own data. The mirror image of SOURCE: where a source column is an externally-written leaf, an export column is an externally-READ leaf. It joins the run plan like a computed column (its mappings are dependencies, so a changed input re-pushes) but nothing may depend on it in turn, nobody may edit it (a hand-edited receipt would silently pin the row out of future pushes), and re-running it means "push again", not "re-answer".

SEQUENCE cells hold a contact's live status in an email sequence, or the messages it sent them, written by the outreach send engine and nobody else: an externally-written leaf with no run plan, no dependencies, no user edits, no retyping. A status column, like EXPORT receipts, may not be referenced in a formula: the status only exists to be looked at, never derived from. A messages column may, the way a SOURCE record may: the engine requests a run of its dependents whenever it rewrites a cell. The columns are created by the sequence that targets the table, not from the add-column catalog.

Available options:
manual,
formula,
enrichment,
source,
export,
sequence
​
position
integer
required
​
requires_recompute
boolean
required

Whether the update marked the column for recompute. The run itself arrives via the active-runs poll, never in this response.

​
supported_filter_operators
enum<string>[]
required

Every filter operator this column admits, in display order. The server owns the list so a picker cannot offer a pairing the rows query will reject: value operators follow the storage slot, and a computed column additionally admits the execution-state family (has an error, has results, has not run, is stale, ...), which reads run metadata a manual column never writes.

A row filter predicate.

Which operators are legal depends on the column's data type; the service validates the pairing and rejects a mismatch, so an operator here is a vocabulary entry rather than a promise it applies everywhere.

Two families live here. The VALUE operators ask about what a cell holds and are keyed off the column's storage slot. The STATE operators ask about what the last run DID to the cell (errored, skipped, never ran, went stale) and are keyed off the column's kind instead: they read the compute metadata that only a computed column ever writes, and mean nothing on a hand-typed one.

Available options:
eq,
neq,
gt,
gte,
lt,
lte,
contains,
not_contains,
contains_any_of,
not_contains_any_of,
starts_with,
is_true,
is_false,
is_empty,
is_not_empty,
has_error,
has_no_error,
has_results,
has_no_results,
has_not_run,
is_stale,
is_not_stale,
run_condition_not_met,
run_stopped
​
table_id
string<uuid>
required
​
type_options
SelectOptions · object
required

Per-type options; null means the type's defaults.

​
updated_at
string<date-time>
required
​
ai_made
boolean
default:false

Whether the AI assistant created this column through a workspace action. A fact about who made it, not a state: it stays true after a person edits the column.

​
auto_run
boolean
default:true

Whether data changes recompute this column by themselves; explicit runs ignore it.

​
pending_recompute
boolean
default:false

The definition has changed since these cells were last computed, so they are stale. Set by a save made with suppress_run, cleared when the column next finishes a run.

​
refresh_interval_hours
integer
default:0

Self re-run cadence in hours; 0 is off.

​
run_condition
ManualColumnDefinition · object

The per-row gate, verbatim; null runs every row.

​
run_condition_group_id
string<uuid> | null

When set, run_condition is inherited from this column group and is rewritten whenever the group's changes. Set a run_condition on the column to override it, or clear the column's to inherit again.

​
run_condition_view_id
string<uuid> | null

When set, the column follows this saved view's filter as its run condition. The engine evaluates view membership at run time rather than reading run_condition. Editing the run condition directly detaches from the view.

​
run_delay_seconds
integer
default:0

Pre-run wait in seconds; 0 runs immediately.