Storefront
Start Store Connection
Begin connecting a store. The store's owner approves the connection on the store itself and the store issues a per-connection API key — no key is ever typed into SKU.io on this path.
Test Store Credentials
Probe the Store API `GET /health` with credentials that have not been saved yet. Nothing is persisted, so this is safe to call as often as a form needs it.
Test Stored Connection
Verify the credentials already stored on the instance and remember what the store reported — the store name and counts are written back onto the instance so the dashboard can name it, and any standing connection error is cleared on success. Takes no body.
Update Connection
Replace the store address and/or the API key on an existing instance, then immediately re-verify.
List Instances
Every Storefront integration instance on the tenant, ordered by name. Not paginated and not filterable — a tenant has a handful of connected stores, not a catalogue of them.
Create Instance
Create an instance from a key pasted in by hand — the break-glass alternative to the store's owner-approval flow (Start Store Connection). Creates the instance, its sales channel and its default sync controls, then probes the store once so the dashboard can name it. **A failed probe never blocks creation**; the failure surfaces afterwards as `connection_error` on the instance. The key is stored encrypted and never returned.
Get Instance
One instance with its full settings, connection state, per-entity sync cursors and live counts.
Update Instance
Update an instance's name and settings. Every field is optional — send only what changes; anything absent is left exactly as it was. Unrecognised keys are ignored rather than stored.
Delete Instance
Delete the instance and everything mirrored under it: imported orders and order lines, product listings, shipment records and API logs. By platform convention the sales channel goes too, and with it the SKU.io sales orders that reference it — they cannot outlive the channel row they point at. All of it happens in one transaction.
List Warehouses
The warehouses that may be selected for this instance's inventory push — every unarchived, non-virtual warehouse on the tenant, ordered by name. Feed the ids straight into `inventory.selectedWarehouses` on Update Instance.
Get Instance Dashboard
Everything the instance overview renders: connection state, freshness per sync card, the financial summary for the chosen window, entity counts, and a Sync Status block that is honest about which sweeps actually run in this environment.
List Activity Log Entries
Paginated activity recorded against this instance: order imports, sales-order creation and updates, cancellations and refusals, payments, shipment pushes, mapping holds, and the instance-level bulk actions.
List Orders
Every order the store has that SKU.io has mirrored, filtered, sorted and paginated. Archived orders are hidden unless `filter[archived]` says otherwise.
Get Order Filter Options
The distinct values that actually occur on this connection's mirrored orders, for building the list's filter choices without hard-coding the full enumerations. Values are sorted and never include nulls.
Get Latest Order Sync Info
Everything about the state of order importing for this connection: the newest order held, how many orders are waiting on a SKU sales order, how the last import run ended, and when the next automatic run is due.
Refresh Orders from Store
Start an import run that reads the store's orders and mirrors them into SKU.io. Always asynchronous: the response returns immediately with `tracked_job_log_id`, the handle you poll for progress and results.
Bulk Create SKU Orders
Create SKU.io sales orders for mirrored orders that do not have one yet. Unlike an import run, this is never gated by the connection's automatic-creation setting — you asked for it explicitly. Orders that are cancelled, refunded, archived, an unpaid processor checkout, or already linked are skipped.
Bulk Update SKU Orders
Re-read each order from the store, then push what changed into its linked SKU.io sales order: a store cancellation cancels the SKU sales order, a payment taken after import is recorded once, and the buyer's delivery choice is refreshed.
Bulk Archive Orders
Hide mirrored orders from the default list. Archiving is a SKU.io-side flag only — nothing is sent to the store, and nothing is deleted. Orders already archived are left alone, so `archived_count` is the number of orders that actually changed.
Bulk Unarchive Orders
Restore archived orders to the default list. Orders that are not archived are left alone, so `unarchived_count` is the number that actually changed.
Bulk Delete Orders
Permanently remove mirrored orders from SKU.io, together with their lines, their recorded store shipments and any linked SKU.io sales order (which is deleted through the normal sales-order path, so allocations and stock movements unwind properly). Nothing is sent to the store.
Bulk Delete SKU Orders
Delete the SKU.io sales orders that were created from these store orders, while keeping the mirrored store orders themselves. Use it to undo a bad import without losing the mirror.
Get Order
One mirrored order in full.
Delete Order
Permanently remove this mirrored store order from SKU.io, along with its lines, its recorded store shipments and any linked SKU.io sales order (deleted first, through the normal sales-order path). Nothing is sent to the store, and the store's own order is untouched.
Get Order Activity Log
The audit trail for one order, newest first: imports, SKU sales order creation and updates, holds, cancellations pushed to the store, archiving and deletion. Each entry carries the machine-readable `event`, a human `description`, the `properties` recorded with it, and `causer_name` — null when an automatic run did it rather than a person.
Get Raw Order from Store
Ask the store for this order right now and return exactly what it sends back, untouched. Nothing is written: the mirrored order and its stored payload are left alone. Use it to compare what SKU.io holds against what the store currently says.
Refetch Order from Store
Re-read this one order from the store and update the mirror from it, then apply any store-side transitions it implies (cancel the SKU sales order if the store cancelled, record a payment the store has since taken). Runs inline and returns the refreshed order.
Create SKU Order
Create the SKU.io sales order for this one store order, inline. Idempotent: an order that already has one is returned unchanged. Not gated by the connection's automatic-creation setting.
Update SKU Order
Re-apply this order's mirrored data to its linked SKU.io sales order. The store is **not** called: this is the SKU.io-side half of a sync, using whatever the mirror already holds. A store cancellation cancels the SKU sales order, a payment is recorded once, and the buyer's requested delivery method is refreshed.
Push Order Cancellation
Tell the store to cancel this order now, instead of waiting for the next automatic run to push it. The store is asked to move the order to `cancelled`.
Archive Order
Hide this mirrored order from the default list. A SKU.io-side flag only — nothing is sent to the store and nothing is deleted. Archived orders are also skipped by automatic SKU sales order creation.
Unarchive Order
Restore an archived order to the default list.
Delete SKU Order
Delete the SKU.io sales order this store order created, and unlink it. **The mirrored store order stays** — only the SKU.io side is removed, through the normal sales-order path so allocations and stock movements unwind properly. Contrast with Delete Order, which removes the mirror itself.
List Store Products
The store's own catalogue as mirrored into SKU.io — one row per store product, with the SKU.io product it is mapped to.
Get Catalogue Sync Info
Catalogue counts and import watermarks for one connection: what the newest store product is, how many products are mirrored, how many are mapped, unmapped and archived, when the mirror was last written, and the opaque paging cursor the last catalogue import left behind.
Import Store Catalogue
Import the store's catalogue into SKU.io. The work runs in the background: the call returns immediately with an id you can poll for progress, while the import pages through the store on the store's own cursor and writes each page as it arrives — a run that is interrupted keeps everything it already read.
Get Store Product
One mirrored store product with its mapping, images, description and the store's own attribute map.
Get Raw Store Product Payload
The untouched payload the store returns for this product, read LIVE from the store rather than from the SKU.io mirror. Use it to see exactly what the store is sending before SKU.io maps it.
List Orders For Store Product
Every order on this connection that contains this store product, newest placed first (ties broken by newest id). Matching is by the store SKU carried on the order lines, so orders that arrived before the product was mapped are included.
Sync Store Product
Re-read ONE product from the store and update its mirrored row immediately (no background work). Send an empty JSON object as the body.
Get Product Match Suggestions
Suggest a SKU.io product for an unmapped store product. Send an empty JSON object as the body.
Map Store Product
Map one store product to a SKU.io catalog product.
Unmap Store Product
Remove this store product's link to a SKU.io product. No request body.
Bulk Map Store Products By SKU
Auto-match unmapped store products to EXISTING SKU.io products that already carry the same SKU. No human choice is involved and no catalog product is ever created — products with no SKU.io counterpart are simply left unmapped and counted as skipped.
Bulk Map Store Products
Map many store products in one call, with ONE EXPLICITLY CHOSEN TARGET PER ROW. This is the shared bulk-mapping contract every SKU.io sales channel implements, byte-identical.
Create SKU.io Product From Store Product
Create ONE SKU.io catalog product from this store product and map the two together.
Bulk Create SKU.io Products From Store Products
Create SKU.io catalog products from unmapped store products, then map them. A store product whose SKU already exists in the SKU.io catalogue is linked to it rather than duplicated.
Check Store Products Are Archiveable
Pre-flight check: which of these store products can be archived, and why not.
Bulk Archive Store Products
Archive store products — they stay in SKU.io but drop out of the product list unless you ask for archived rows with `filter[archived]=true` or `all`. Archiving does not touch the store and does not touch the SKU.io catalog product.
Bulk Unarchive Store Products
Bring archived store products back into the product list. Unarchiving has no blockers — every selected product is unarchived.
Check Store Products Are Deleteable
Pre-flight check: which of these store products can be deleted.
Bulk Delete Store Products
Permanently delete the SELECTED MIRRORED STORE PRODUCTS from SKU.io, along with their mapping links. This does NOT delete anything on the store, and it does NOT delete the SKU.io catalog products they were mapped to.
Export Store Products
Export the store-product list as a spreadsheet FILE DOWNLOAD.
Get Product Push Summary
The state of the OUTBOUND catalogue push — SKU.io's products going out to the store. This is the opposite direction to everything else in this folder, and it is counted over the products SKU.io has published to the store, not over the store's mirrored catalogue.
Push Products To Store
Push SKU.io's catalogue OUT to the store. The work runs in the background: the call returns immediately with an id you can poll for progress.
Get Field Mappings
Which store field fills which SKU.io field when a catalog product is created from a store product, plus the option lists a mapping is chosen from.
Update Field Mappings
Replace this instance's custom field mappings wholesale. Whatever you send becomes the complete custom set; a mapping you leave out is gone, and the default for that target applies again.
List Inventory Comparison
One row per SKU this store sells, comparing the quantity SKU.io would send right now against the quantity the store was last told. Rows are the outbound listings for connection `1`; nothing here is fetched live from the store.
Get Inventory Summary
The counts behind the inventory comparison, plus the settings that produced them. Every count is derived with exactly the same predicates `filter[status]` uses on the list endpoint, so a count and the filtered list it links to can never disagree.
Push Inventory
Queue an outbound inventory push for this connection and return immediately with the id of the tracked run, so progress can be polled.
List Fulfillments
The shipments SKU.io has pushed, or tried to push, to this store. One row per SKU.io sales order fulfillment that reached this connection, newest first.
Get Fulfillment Stats
Shipment counts for this connection, all-time:
Submit Fulfillment
Push one shipment to the store and wait for the answer. The path id (`812` here) is the SKU.io SALES ORDER FULFILLMENT id — not the id of a row returned by the list endpoint. No request body.