Store

The Store action node reads from, writes to and deletes from a managed store: a timestamped series of values indexed by a key. Each write adds a new entry, or replaces one existing entry when the write names it with an Entry ID. Use it to carry state across workflow runs, compare current values against historical ones, collect several documents that belong together (for example every packing slip of one purchase order), or accumulate a running series without building a dedicated external database.

When to use Store

You want to track how a value changes over time across runs: prices, quantities, scores.
You need to compare the current run’s data against the most recent previous value without calling an external API.
You want to accumulate a running total or average across multiple runs (e.g., daily volume, average invoice amount).
A downstream HTTP action or Validation node needs historical context that does not live in the current document.

For purely within-run named values, use Variable instead. Store is for values that must outlive a single run. To pair up related documents that arrive as separate runs and continue with all of them together, use Correlate instead.

Prerequisites

Before using a Store node, create at least one store under Settings > Stores. If no store exists, the node cannot be configured. Every store carries a required value schema that describes the object held under each key. A Set node’s value must match that schema, so design the store first and the node second.

Modes

The Store node operates in one of three modes, selected in the node editor: Set, Get and Delete.

Set

Writes the resolved value under the given key. Without an Entry ID the value is appended as a new entry. With an Entry ID, the node writes the one entry that key and Entry ID identify: it is created the first time and replaced on every later write. The write is idempotent per run and node: if the same Store node runs twice for one workflow run, only one write happens.

Field	Type	Required	Description
Store	select	Yes	The managed store to write to
Key	text	Yes	The key to write under. Supports template expressions, e.g. `{{extract.payload.sku}}`
Entry ID	text	No	Identifies one entry under the key, such as a packing slip number. Supports template expressions, e.g. `{{extract.payload.slipNumber}}`. Leave blank to append a new entry on every write
If entry exists	select	No	Shown when an Entry ID is set. Replace (the default) overwrites the stored entry. Fail keeps the first value and fails the run when the entry already exists
Value	JSON	Yes	A JSON object to store, written in the JSON editor. Map fields from upstream with template expressions, e.g. `{ "unitPrice": "{{extract.payload.unitPrice}}" }`
Fail on null value	toggle	No	When on, the run fails if any part of the value comes back empty (see below). Default off

The value must be a JSON object, not a scalar or an array: a workflow whose Set value is anything else fails validation on save. The object must also match the store’s value schema. Ingestly adds a reserved key property carrying the entry key to every stored value, and a reserved entryId property when the write has an Entry ID, so never declare key or entryId in the schema or in the node’s value.

Entry ID

An Entry ID turns one key into a set of named entries. Writing the same key and Entry ID again replaces that entry in place, so a corrected document overwrites the earlier one instead of adding a duplicate. Entries without an Entry ID under the same key are left alone and still read back.

A replaced entry counts as newly written: it becomes the Latest entry, falls inside a recent Window again, and its age retention restarts.
The Entry ID is trimmed. An Entry ID template that resolves to nothing, or to a list or object, fails the step rather than silently appending.
With If entry exists set to Fail, the first write wins and a later write of the same entry fails the run with a message naming the key and Entry ID. A retry of the same run is never treated as a conflict.
Entry IDs are at most 256 characters after the template resolves.

A value larger than 256 KB is rejected and the step fails.

During a dry run, Set validates and previews the value without saving it. A later Get reads committed entries and cannot see the previewed value, so its result can differ from a live run.

Fail on null value

By default, an expression that resolves to nothing renders as an empty string inside the stored object and the run succeeds. Turn Fail on null value on to make that a hard failure instead. The check covers three cases and names what went wrong:

An unresolved reference: the message quotes the token, for example the reference {{extract.payload.total}} did not resolve.
A JSON-null leaf, named by its dotted path, for example 'lines[0].sku' resolved to a null or empty value.
An empty or whitespace-only string leaf, named by that same dotted path.

Built-in helpers such as {{uuid}} and {{now}} always resolve, so they are never reported as unresolved. An empty object or an empty array is not a leaf and does not trip the check.

Set inside a Loop

A Set or Delete inside a Loop body is buffered per item, not written straight away. Buffered writes are flushed together, in order, as the loop progresses; a failed item’s own writes are discarded and never persisted. A Get in the same loop reads committed entries only: it never sees the loop’s own pending writes. With If entry exists set to Fail, a second item writing the same entry fails at once.

Get

Reads the series for a key and returns the result as the node’s payload. Entries are ordered by when they were last written, so a replaced entry counts as the newest. Three operations are available.

Field	Type	Required	Description
Store	select	Yes	The managed store to read from
Key	text	Yes	The key to read. Supports template expressions
Entry ID	text	No	Reads only the entry with this Entry ID under the key. Supports template expressions. When set, Operation is hidden and the payload is that one entry, or `null` when it does not exist
Operation	select	Yes	What to return: `Latest`, `Last N`, or `Aggregate`. Not used when an Entry ID is set
Window	section	No	Optional time filter: `Relative` or `Range` (see below)
Fail when not found	toggle	No	When on, the run fails if the read matches nothing, for example an unknown key or a window with no entries. Default off, so a miss succeeds with a `null` payload and `found` set to `false`

Latest

Returns the single most recent entry for the key. The result lands at payload. Stored JSON is parsed back into structured data, so read its fields directly, for example {{getPrice.payload.unitPrice}}. metadata.store.found is false and payload is null when no entry matched.

Last N

Returns the most recent N entries as a list. The result lands at payload (array, newest first). Empty array when no entries matched.

Field	Type	Required	Description
N	number	Yes	How many recent entries to return, between 1 and 1,000

Aggregate

Computes a number over the series. The result lands at payload (number). An empty series yields 0 for Total and Count, and null for Average, Lowest, and Highest.

Field	Type	Required	Description
Aggregate function	select	Yes	`Average`, `Total`, `Lowest`, `Highest`, or `Count`. Average is preselected when you pick Aggregate, and an older configuration that never chose a function runs as Average
Value path	text	No	The path to the numeric field inside each stored entry, e.g. `amount` or `items[0].price`. Shown for every function except `Count`

The node reads Value path out of each stored entry before computing the aggregate. Entries where the path does not resolve to a number are skipped. Leave it blank only when the stored value is itself a number: values written by a Set node are always objects, so a blank path aggregates nothing for them.

Value path is a literal path, not a template expression. It addresses the stored value’s own shape, so use the entry’s field names with dots for nested objects and brackets for array elements (amount, data.amount, items[0].price). A {{token}} there is rejected when you save the workflow, and a workflow saved before this rule fails the step at run time with the same message rather than aggregating silently to 0 or null.

The editor suggests paths sampled from entries already stored under the configured key. Click a suggestion to fill the field. Upstream workflow fields are deliberately not offered, because the path is read against the stored entry rather than the current run.

Window

All three operations accept an optional Window to restrict which entries are included.

Window type	Fields	Description
Relative	Amount, Unit	Entries written in the last N hours, days, weeks, or months. Amount is between 1 and 10,000
Range	From, To	Entries between two timestamps. Both fields support template expressions, e.g. `{{vars.payload.startDate}}`

Range bounds are UTC only. A timestamp carrying a non-zero offset (for example 2026-01-01T10:00:00+05:30) is rejected at run time and the step fails. A timestamp with no zone at all (2026-01-01T10:00:00) is read as UTC.

When no window is set, all entries for the key are included.

Delete

Removes entries from the store. The payload is the number of entries removed.

Field	Type	Required	Description
Store	select	Yes	The managed store to delete from
Key	text	Yes	The key to delete under. Supports template expressions
Target	select	Yes	One entry deletes the entry with the given Entry ID. All entries deletes everything stored under the key, including entries written without an Entry ID
Entry ID	text	With One entry	The entry to delete. Supports template expressions

A delete that matches nothing succeeds with 0. During a dry run, Delete counts the entries it would remove and deletes nothing.

Output

The node’s data lives in payload and identity/provenance fields are under metadata.store. Read downstream as {{storeName.payload}} or {{storeName.metadata.store.<field>}} where storeName is the node name in your workflow. payload - the operation result:

Field	Present when	Description
(root, boolean)	Set mode	`true` when the entry was written (appended or replaced), or held by an enclosing Loop for commit at the next checkpoint. `false` when an internal retry replayed a write that had already committed, so nothing new was written
(root, number)	Delete mode	How many entries were deleted. Inside a Loop, the number it will remove, counting the loop’s own earlier Sets and Deletes
(root, object/array/number)	Get mode	The retrieved value: the most recent entry (Latest), an array of entries newest-first (Last N), or the computed number (Aggregate). Stored JSON is parsed back into structured data. `null` when no entry matched

metadata.store - identity and provenance:

Field	Present when	Description
`id`	Always	The ID of the store that was accessed
`key`	Always	The resolved key that was read or written
`entryId`	Set or Get with an Entry ID, Delete of one entry	The resolved Entry ID
`found`	Get mode	`true` when at least one entry matched the key (and window, if set)
`count`	Get mode	Entries behind the result, after window filtering: `1` for a Latest hit, the number returned for Last N, the number of values aggregated for Aggregate

found and count are present for every Get shape, including a miss and an empty aggregate series, where count is 0. A downstream node can branch on {{getPrice.metadata.store.count}} without first checking that the field exists.

Limits

The workflow editor enforces the same bounds the API publishes, so a configuration the editor accepts is not refused when you save.

Limit	Value
Key length	256 characters, after the key expression resolves
Entry ID length	256 characters, after the Entry ID expression resolves
Value size	256 KB per entry
N (Last N)	1 to 1,000
Relative window amount	1 to 10,000

When a store is missing

Deleting a store that a workflow still references breaks that workflow:

The node editor shows Store not found in place of the store name, with an inline note telling you the selected store no longer exists in this workspace.
Saving or validating the workflow reports a validation error naming that node, and the workflow stays invalid (and therefore cannot run) until you point the node at a store that exists.
If the workflow does run against a deleted store, the step fails with Store not found or was deleted.

Moving a workflow between workspaces

Workflow exports carry store references by name, not by ID. On import, Ingestly rebinds each Store node to the store with the same name in the destination workspace. When no store matches that name (or more than one does), the reference is cleared and reported: the import warning lists unbound connectors, stores, and forward targets together, so open each affected node and pick a replacement. See export and import.

Example: price change detection

A purchase-order workflow captures each line item’s unit price on every run and surfaces a warning when the price has changed. Set node (runs when the order arrives):

Store: prices
Key: {{extract.payload.sku}}
Value: {
  "unitPrice": "{{extract.payload.unitPrice}}"
}

Get node (runs in the next workflow run for the same SKU):

Store: prices
Key: {{extract.payload.sku}}
Operation: Latest

Downstream Variable node computes the delta:

priceChanged: {{getPrice.metadata.store.found && getPrice.payload.unitPrice != extract.payload.unitPrice}}
previousPrice: {{getPrice.payload.unitPrice}}

A downstream Validation node can then gate on {{vars.payload.priceChanged}}, or an If node can branch on it. Filter is not the node for this: it only keeps or drops pages of one document and never branches on a variable.

Example: packing slips per purchase order

A purchase order arrives as several packing slips over a few days, and a corrected slip can be resent. The invoice run later needs the received quantities from every current slip, then closes the order. Set node (runs for each packing slip):

Store: packing-slips
Key: po-{{extract.payload.poNumber}}
Entry ID: {{extract.payload.slipNumber}}
Value: {
  "qty": "{{extract.payload.totalQty}}"
}

A resent slip with the same number replaces its earlier entry, so the store always holds one entry per slip. Get node (runs for the invoice):

Store: packing-slips
Key: po-{{extract.payload.poNumber}}
Operation: Aggregate
Aggregate function: Total
Value path: qty

The total counts each current slip once. Use Last N instead to receive every slip as an array. Delete node (after the invoice is sent):

Store: packing-slips
Key: po-{{extract.payload.poNumber}}
Target: All entries

Inputs and outputs

Allowed inputs: All trigger nodes and all action nodes. Output: The node result with data at payload and identity fields at metadata.store, as described in the Output section above.

Credits

Store nodes are free. They consume 0 credits per execution.

Stores settings

Create and manage store resources

Variable

Define named values that live only within a single run

HTTP action

Call external APIs to read or write data mid-workflow

Expressions and filters

Template syntax for key and value fields

Getting started

Learn

Guides

Reference

Administration

When to use Store

Prerequisites

Modes

Set

Entry ID

Fail on null value

Set inside a Loop

Get

Latest

Last N

Aggregate

Window

Delete

Output

Limits

When a store is missing

Moving a workflow between workspaces

Example: price change detection

Example: packing slips per purchase order

Inputs and outputs

Credits

Stores settings

Variable

HTTP action

Expressions and filters

​When to use Store

​Prerequisites

​Modes

​Set

​Entry ID

​Fail on null value

​Set inside a Loop

​Get

​Latest

​Last N

​Aggregate

​Window

​Delete

​Output

​Limits

​When a store is missing

​Moving a workflow between workspaces

​Example: price change detection

​Example: packing slips per purchase order

​Inputs and outputs

​Credits

​Related

Stores settings

Variable

HTTP action

Expressions and filters

When to use Store

Prerequisites

Modes

Set

Entry ID

Fail on null value

Set inside a Loop

Get

Latest

Last N

Aggregate

Window

Delete

Output

Limits

When a store is missing

Moving a workflow between workspaces

Example: price change detection

Example: packing slips per purchase order

Inputs and outputs

Credits

Related