Stock take statuses, fields & list

A stock take is a warehouse-scoped count document that reconciles what SKU.io thinks is on your shelves with what a physical count finds. Every take carries a status, a mode, a count date, a variance direction, and a set of items — one line per product. This page is the field-level lookup for all of it: the three statuses and what each allows, the variance-direction and root-cause codes, the list (filters, sorts, tabs, view modes) and detail sub-views, the CSV export, and every field on the StockTake, StockTakeItem, and reconciliation objects.

For why the model works the way it does — full-count vs adjustment mode, the snapshot-vs-count-date split, and what finalizing does to your books — read the concept How stock takes work. For the tasks themselves, see Create a stock take, Count stock, Finalize a stock take, and Amend a stock take.

You manage stock takes under Inventory → Stock Takes.

Two modes decide the path

The mode is chosen when you create a take and never changes. It decides which statuses a take passes through and how each item records its variance.

Mode	On-screen label	Item records	Lifecycle
full_count	Full Count	A qty_counted per line; variance is counted minus system on-hand.	Draft → Open → Closed (a snapshot is captured at Open).
adjustment	Adjustment	A signed adjustment_qty per line; the delta is the variance.	Draft → Closed (finalized directly, no snapshot).

The status tables below call out which actions apply to which mode.

Status

A stock take has exactly one status at a time, stored in the status field. New takes start Draft.

Value	On-screen label	Meaning	Inventory effect
draft	Draft	Editable staging. Items are added and scoped; adjustment-mode deltas are entered here.	None — no snapshot, no movements, no accounting.
open	Open	Full-count only. A system snapshot is captured and counters enter qty_counted.	Snapshot recorded; no movements yet.
closed	Closed	Finalized. Variance is written to stock, cost, and the books.	Movements and FIFO layers created; value and accounting posted.

draft — staging, no inventory effect

Draft is the editable staging state. You add items, set the warehouse, and — in adjustment mode — enter each line's adjustment_qty. Nothing is committed: there is no snapshot, no movement ledger entry, and no accounting transaction. A draft take is freely editable and freely deletable.

Where a draft goes next depends on mode:

• Full-count draft → Open. Initiate captures the snapshot and moves the take to Open. Initiate is rejected on an adjustment-mode take with a clear message (use finalize-adjustment instead), and a take must have at least one item to initiate.
• Adjustment draft → Closed. Finalize adjustment posts the deltas and closes the take directly, skipping Open.

open — snapshot taken, counting in progress

Open exists only for full-count takes. When you initiate, SKU.io stamps each item with a point-in-time snapshot (snapshot_inventory, snapshot_available, snapshot_committed_to_fulfillment) and the take's snapshot_at. Counters then enter qty_counted per line. Available actions while Open:

Action	What it does
Re-snapshot	Recaptures the system quantities against current stock, re-baselining the count if inventory moved since Open.
Zero out	Bulk-sets qty_counted for every line, in one of three modes: zero all (0 everywhere), keep submitted (each line's submitted / committed-to-fulfillment quantity), or keep all allocated (each line's full allocated total — pending + submitted). Keep all allocated preserves stock that orders have already claimed rather than counting it to zero.
Revert to draft	Clears the snapshot fields and value, returning the take to Draft for re-scoping.
Finalize & reconcile	Posts the variance and closes the take. Every item must have a qty_counted first — hasFullQuantities() blocks finalize while any line is uncounted.

Movements that happen after the snapshot but before you finalize are tracked separately as during-count movements — see Detail sub-views and the reconciliation flow in Finalize a stock take.

Blind counts hide the system quantity

When a take is created with blind on (is_blind), the system on-hand for an item that hasn't yet been counted is withheld, so the counter records what they physically find without anchoring to the expected number. Once a line's qty_counted is set, its snapshot is revealed for variance review.

closed — finalized, inventory and accounting posted

Closing is terminal. Finalizing (full count) or finalize-adjustment (adjustment) writes the variance into FIFO layers and the movement ledger, sets value_change and variance_direction, and posts the accounting transaction. A closed take isn't re-approved, but it supports these post-close actions:

Action	When it's available
Reverse	Undoes all inventory effects — allowed only while no FIFO layer created by the take has been consumed, and not for channel-managed (Amazon FBA/AWD/WFS) stock.
Compensating adjustment	Creates a child adjustment take to correct a closed take whose FIFO layers have already been consumed (so it can't be reversed).
Cost correction	Re-costs the closed take's lines and reposts accounting, without touching quantities.
Edit notes / re-date	Edits notes or moves date_count. Re-dating replays FIFO consumption and COGS; preview the impact first with the reallocation preview.

Delete on a closed take reverses its inventory effects, but is blocked when any FIFO layer it created has been consumed (fulfilled_quantity above zero). The deletable flag and delete_blocked_reasons on the take report this per item; the list's Deletable check exposes the same result in bulk.

Re-dating into a locked period is refused

Editing a closed take's date_count into a locked accounting period is rejected (StockTakeDateInLockedAccountingPeriodException), as is a reallocation that would cross a locked period. Amend the accounting period first.

variance_direction

At finalize, SKU.io summarizes the whole take's variance into a single variance_direction value. It compares each item's variance — adjustment_qty in adjustment mode, qty_counted for an initial count, otherwise qty_counted − snapshot_inventory — and rolls the signs up.

Value	On-screen chip	Chip color	Set when
(null)	(no chip)	—	No item had a non-zero variance.
positive	Positive	Green	Every non-zero item was a gain.
negative	Negative	Red	Every non-zero item was a loss.
mixed	Mixed	Amber	The take had both gains and losses.

variance_direction is a stored column, so it's a filterable and sortable list dimension. It's null until the take closes.

Variance root-cause codes

Each item can optionally carry a variance reason (variance_reason) — a cycle-counting root-cause code that records why the counted quantity differs from the system on-hand, so variance can be analysed by cause rather than as one undifferentiated adjustment. It's nullable and backwards-compatible: leaving it blank is fine.

Value	On-screen label	Typical use
receiving_error	Receiving Error	Stock was mis-counted or mis-booked at receipt.
picking_error	Picking Error	A pick took the wrong quantity or wrong SKU.
mislabel	Mislabel	Product was labelled as the wrong SKU.
damage	Damage	Units were damaged and pulled from sellable stock.
shrinkage	Shrinkage	Loss with no identified cause (theft, spoilage).
unknown	Unknown	Cause not determined.

The reason is chosen per line on the count table and stored on the item; it doesn't change the quantity or cost math, only the analytics.

The stock takes list

The list at Inventory → Stock Takes is server-paginated (10 per page by default) and built on the standard datatable stack — search, filters, saved views, sorts, column selector, and three view modes (table, grid card, and mobile card).

Filters

The following filters are exposed (via StockTakeListRepository), most also as quick tabs and dropdowns above the table:

Filter	Type	Notes
Search	text	Matches take ID (exact), notes, and warehouse name.
Status	tab / select	All, Draft, Open, Closed.
Mode	select	All, Full Count, Adjustment.
Warehouse	select	Filters by warehouse.
Initial count	select	All, Yes, No (is_initial_count).
Variance direction	select	All, Positive, Negative, Mixed.
Count date	date range	date_count between two dates.
Created / Updated	date range	created_at / updated_at ranges.
Value change	numeric	Filters on value_change.
Archived	select	Default hides archived; only shows archived, all shows both.

Sorts

Sortable columns: ID, Count Date (date_count), Status, Value Change, Variance Direction, Created, and Updated. The default sort is newest first (-id).

Columns

The table shows ID, Status, Mode, Warehouse, Count Date, Value Change, Variance Direction, Notes, Created, and Updated. The list endpoint returns a lightweight resource (StockTakeListResource) that omits the item lines — those load only on the detail page.

Detail sub-views

Open a take to its detail page. Beneath the header, a set of tabs exposes the take's data. Which tabs appear depends on status:

Tab	Shown when	Contents
Items	Always	One row per product — SKU, snapshot, counted/adjustment quantity, unit cost, variance reason, and lot fields. Includes the Export action.
FIFO Layers	Closed	The FIFO layers the take created, with product, warehouse, and cost.
Inventory Movements	Closed	The movement ledger entries the take wrote (type Stock Take).
Reconciliation Log	When entries exist	The audit of reconciliation actions taken at finalize (see below).
Activity	Always	The activity log filtered to this take as subject.

While a take is Open, the header separately surfaces a Movements Since Snapshot count and dialog — the during-count movements that landed after the snapshot (and aren't this take's own). These feed the reconciliation preview when you finalize.

Reconciliation log actions

The Reconciliation Log records what finalize did when a count collided with in-flight orders. Each entry carries an action:

Action	Meaning
adjustment_applied	The item's variance was written to stock.
count_adjusted	A line's qty_counted was changed during reconciliation (for example, to absorb during-count movement).
item_removed	A line was dropped from the take during reconciliation.
fulfillment_cancelled	An open shipment was cancelled to free stock the count removed.
fulfillment_cancel_failed	A cancellation was attempted but failed (see the entry detail).
order_deallocated	An order's allocation was released.
order_backordered	An order line was pushed to the backorder queue because the count left it short.
allocation_downgraded	A committed allocation was downgraded to planned.

Export count lines

The Export button on the Items tab downloads the take's lines as CSV (stock_take_lines.csv). The columns depend on status:

Column	Always	Notes
id	Yes	The product ID.
sku	Yes	Product SKU.
barcode	Yes	Product barcode.
name	Yes	Product name.
snapshot_inventory	Past draft only	The captured system quantity.
qty_counted	Past draft only	The counted quantity.
adjustment	Past draft only	qty_counted − snapshot_inventory.
unit_cost	Past draft only	The item's unit cost (falls back to the product's).

A Draft take exports only the four identity columns — it has no snapshot yet. The same shape is the round-trip template for the import-lines upload, so an exported file can be edited and re-imported.

StockTake fields reference

The fields on the take itself (StockTake model / StockTakeResource):

Field	Type	Description
id	int	Primary key and the take's reference.
date_count	date-time	The effective date the count applies to — drives FIFO placement and the accounting date.
snapshot_at	date-time, nullable	When the system snapshot was captured (full count, at Open). Null for adjustment mode.
warehouse_id	int	The warehouse the take counts. Every line and movement is scoped to it.
mode	string	full_count or adjustment.
condition	string, nullable	Optional condition label; combined with warehouse it enforces initial-count uniqueness.
is_initial_count	bool	An opening count that establishes stock from zero (snapshot_inventory treated as 0).
is_blind	bool	Hides the system quantity for uncounted lines during counting.
status	string	draft, open, or closed.
value_change	float	Total cost value the take moved once finalized.
variance_direction	string, nullable	positive, negative, mixed, or null.
notes	string	Free-text notes; searchable and editable after close.
parent_stock_take_id	int, nullable	Links a compensating adjustment back to the take it corrects.
source_type / source_id	string / int, nullable	Polymorphic origin when a take is created by another process (for example, an FBA inbound).
batch_accounting_transaction_id	int, nullable	The batch accounting transaction the finalized take posted into.
archived_at	date-time, nullable	Set when archived; archived takes are hidden from the default list.

The resource also returns derived fields — deletable, delete_blocked_reasons, during_count_movement_count (open takes), and the parent_stock_take / child_stock_takes summaries.

StockTakeItem fields reference

One item per product on the take (StockTakeItem model / StockTakeItemResource):

Field	Type	Description
id	int	Primary key.
product_id	int	The counted product.
qty_counted	float, nullable	The physical count (full-count mode). Null until counted.
adjustment_qty	float, nullable	The signed delta (adjustment mode).
quantity_adjusted	float, derived	qty_counted − snapshot_inventory — the effective variance for a full count.
unit_cost	float	Cost basis, persisted at snapshot time from best-available COGS.
item_realized_unit_cost	float, closed only	The actual per-unit cost realized from FIFO once the take closed.
variance_reason	enum, nullable	A root-cause code.
warehouse_location_id	int, nullable	The counted bin; stamped onto the item's variance movements.
snapshot_inventory	float	System on-hand captured at Open (0 for an initial count).
snapshot_available	float, nullable	Available quantity at snapshot.
snapshot_committed_to_fulfillment	float, nullable	Units committed (submitted) to fulfillment at snapshot — the Rsv (Submitted) count-table column.
snapshot_reserved	float, nullable	Total allocated units at snapshot (pending + submitted). Drives the Rsv (Pending) count-table column (snapshot_reserved − snapshot_committed_to_fulfillment) and the Keep all allocated zero-out mode. 0 for an initial count.
lots	array, nullable	Lot rows (batch number, manufacture/expiry date, quantity, notes) for lot-tracked products.
lot_allocation	array, nullable	The chosen FIFO-layer consume allocation for a negative-variance override.
integration_unique_id	string	Dedupe key for items sourced from an integration.

Each item resource also echoes the product's lot configuration — is_lot_tracked, lot_tracking_method, shelf_life_days, near_expiry_threshold_days, min_remaining_shelf_life_days — so the count table can enforce lot entry.

"Reserved" on a count means allocated, not a stock state

SKU.io has no "reserved" inventory status — the product list column that once read "Reserved" is now On Hold. On a stock take, Rsv (Pending) and Rsv (Submitted) are allocation figures, not a status: snapshot_reserved holds the total allocated (pending + submitted) at snapshot and snapshot_committed_to_fulfillment holds the submitted portion, so Rsv (Pending) is the two subtracted. For the real states — on-hand, available, allocated, on-hold, non-sellable, incoming, and in-transit — see Stock states and the stock states and fields reference. On-hand reconciles as Available + Allocated + On Hold + Non-Sellable.

Reconciliation preview and result fields

When you finalize a full count, SKU.io builds a preview of the variance against current stock and any orders it touches, then returns a result after you execute. These objects power the reconciliation dialog in Finalize a stock take.

Preview — per item

Each item in the reconciliation preview (StockTakeReconciliationItemData) carries:

Field	Meaning
snapshot_inventory / qty_counted	The snapshot and the count.
variance	Count minus snapshot.
net_movement_during_count	Net stock movement between snapshot and finalize.
adjusted_snapshot / adjusted_variance	Snapshot and variance re-based to absorb during-count movement.
current_available	Available stock right now.
current_reserved_pending / current_reserved_submitted	Allocations pending vs submitted to a shipment.
current_on_hand	On-hand right now.
shortfall	How far the count falls below what open orders need.
affected_orders	The orders a negative variance would disrupt (see below).
during_count_movements	The movements that landed during the count.

Preview — affected order

Each entry in affected_orders (AffectedOrderData) describes one order at risk:

Field	Meaning
sales_order_id / sales_order_reference	The order and its reference.
sales_order_line_ids	The affected lines.
quantity	Units in contention.
order_date / status	Order date and order status.
fulfillment_id / fulfillment_status	The shipment, if any, and its status.
shipping_provider_name / is_sent_to_provider	Provider and whether it was dispatched.
is_cancellable	Whether SKU.io can cancel it as part of reconciliation.

Result

After you execute, the result (StockTakeReconciliationResultData) reports what happened:

Field	Meaning
success / stock_take_finalized	Whether reconciliation succeeded and the take closed.
total_value_change	The cost value moved.
cancelled_fulfillments / failed_cancellations	Shipments cancelled, and any that couldn't be.
adjusted_items	Lines whose qty_counted was changed during reconciliation.
removed_items	Lines dropped from the take.
backordered_items	Order lines pushed to backorder.
downgraded_allocations	Allocations downgraded from committed to planned.
finalization_error	The error message if finalize failed.

Next steps

• How stock takes work — the model behind these fields
• Create a stock take and Count stock
• Finalize a stock take — the reconciliation flow
• Amend a stock take — reverse, re-date, and delete
• Stock states and the stock states and fields reference
• FIFO layers & how COGS is realized and the FIFO/COGS reference
• The inventory movement ledger and the movement types & fields reference