Extensiv Trigger

The Extensiv Trigger starts a workflow when Extensiv (3PL Warehouse Manager) reports an event. When an order, receipt, adjustment, assembly, item, or inventory record is created, changed, or moved through its lifecycle, Extensiv posts a notice to Splice, and this trigger turns it into a workflow execution. Use it to react to warehouse activity in real time: sync orders into another system, generate and transmit EDI, confirm shipments, update inventory, or raise exceptions as they happen.

Overview

Use the Extensiv Trigger when you need to:

React to order lifecycle events - Start a workflow the moment an order is created, updated, completed, confirmed, canceled, allocated, picked, packed, or deleted
Act on inbound receipts - Respond to receipt creation, updates, confirmation, and completion as goods arrive
Track inventory and item changes - Run a workflow on inventory summary updates, item create/update/delete, and stock adjustments
Follow fulfillment progress - React to pick-job assignment, pick/pack progress, and line-item pick/pack events
Keep systems in sync - Push Extensiv changes into a TMS, ERP, accounting system, or data warehouse
Drive EDI from warehouse activity - Generate and send EDI (e.g. 940/943/944/945/947) in response to Extensiv events

Endpoint & Setup

The Extensiv Trigger is delivered over the same HTTP ingress as the Webhook trigger. Extensiv posts events to the workflow's public endpoint:

POST https://<your-splice-api-domain>/hook/{workflowId}

Configure an Extensiv webhook/notification subscription to send events to this URL (copy it from the workflow), then choose which events should start the workflow with the Action setting below.

Trigger vs. the Extensiv API

The trigger node only receives the inbound event. If a workflow needs to call back into Extensiv (to fetch related records or push updates), use an HTTP Request or an Extensiv service node with a separate Extensiv API credential. That credential is independent of this trigger.

Authentication

The trigger has an Authentication setting that controls how inbound calls are verified:

Option	Value	Behavior
None	`none`	(default) The endpoint accepts the inbound POST without signature verification. Secure the integration at the Extensiv side and validate the payload inside the workflow.
RSA	`rsaAuth`	The inbound call is verified against an RSA credential before the workflow runs, so only calls signed with the matching key start the workflow.

When RSA is selected the node uses the RSA credential (rsaAuth, optional in the metadata). Use it when you want Splice to verify that an inbound event genuinely originated from your Extensiv integration rather than accepting any POST to the public URL.

Configuration

Action (required)

The set of Extensiv events that may start the workflow. Select one or more; only the selected event types trigger a run.

Event	Value	Fires when
Order Create	`OrderCreate`	A new order is created
Order Complete	`OrderComplete`	An order is marked as Complete
Order Update	`OrderUpdate`	A change is saved to an existing order
Order Confirm	`OrderConfirm`	An order is moved to a Closed status
Order Unconfirm	`OrderUnconfirm`	A Closed order is reopened
Order Cancel	`OrderCancel`	An order is moved to a Canceled status
Order Deleted	`OrderDeleted`	An order is removed entirely from the database
Order Fully Allocated	`OrderFullyAllocated`	All of an order's line item quantities are allocated to on-hand inventory
Order Excluded From Pick Job	`OrderExcludedFromPickJob`	An order is removed from an existing pick job, or an associated pick job is deleted
Pick Job - User Assigned	`OrderPickJobUserAssigned`	A pick job has a picker assigned (or re-assigned) to it
Pick Job - User Unassigned	`OrderPickJobUserUnassigned`	A pick job has its assigned picker removed
Order Pick Job Done	`OrderPickJobDone`	A pick job is completed for an order
Pack Started	`OrderPackStarted`	A pack job begins for an order
Pack Complete	`OrderPacked`	An order is fully packed (i.e., when its Pack Done Date is set)
Receipt Create	`ReceiptCreate`	A new receipt is created
Receipt Complete	`ReceiptComplete`	A receipt is marked as Complete
Receipt Update	`ReceiptUpdate`	A change is saved to an existing receipt
Receipt Confirm	`ReceiptConfirm`	A receipt is moved to a Closed status
Receipt Unconfirm	`ReceiptUnconfirm`	A Closed receipt is reopened
Receipt Cancel	`ReceiptCancel`	A receipt is moved to a Canceled status
Receipt Delete	`ReceiptDelete`	A receipt is removed entirely from the database
Adjustment Create	`AdjustmentCreate`	A new adjustment is created
Adjustment Confirm	`AdjustmentConfirm`	An adjustment is marked as Complete
Adjustment Cancel	`AdjustmentCancel`	An adjustment is moved to a Canceled status
Adjustment Update	`AdjustmentUpdate`	A change is saved to an existing adjustment
Adjustment Delete	`AdjustmentDelete`	An adjustment is removed entirely from the database
Assembly Create	`AssemblyCreate`	A new assembly transaction is created
Assembly Cancel	`AssemblyCancel`	An assembly transaction is moved to a Canceled status
Assembly Delete	`AssemblyDelete`	An assembly is removed entirely from the database
Assembly Update	`AssemblyUpdate`	A change is saved to an existing assembly transaction
Assembly Confirm	`AssemblyConfirm`	An assembly transaction is marked as Complete
Order Item Pack	`OrderItemPack`	An order line item is associated with a package
Order Item Unpack	`OrderItemUnpack`	An order line item is unassociated from a package
Order Item Pick	`OrderItemPick`	An order line item is picked
Order Item Unpick	`OrderItemUnpick`	An order line item is unpicked
Item Create	`ItemCreate`	A new item is created
Item Update	`ItemUpdate`	A change is saved to an existing item (including when it is deactivated)
Item Delete	`ItemDelete`	An item is removed entirely from the database
Inventory Summary Update	`InventorySummaryUpdate`	A stock status record is created, changed, or deleted (i.e., when the on-hand or available amount changes for an item)

Output

The trigger emits a single output keyed by the node's name. Splice wraps the Extensiv notice in a consistent envelope:

event - The Extensiv event type that fired (the value from Action, e.g. OrderCreate, ReceiptComplete, InventorySummaryUpdate).
data - The resource body for the record that changed. Extensiv's hypermedia fields (_links and _embedded) are stripped before delivery; everything else from the resource body is passed through.

The shape of data depends on the resource type (an order event carries order fields, a receipt event carries receipt fields, an inventory event carries item/stock fields, and so on). Extensiv resource bodies use PascalCase field names and nest read-only fields under a ReadOnly object.

An OrderCreate / OrderUpdate event looks like:

{
  "Extensiv Trigger": {
    "event": "OrderCreate",
    "data": {
      "ReadOnly": {
        "OrderId": 772911,
        "CustomerIdentifier": { "Name": "TPV", "Id": 137 },
        "FacilityIdentifier": { "Name": "NJ Warehouse", "Id": 2 },
        "ReferenceNum": "9974564",
        "PoNum": "PO-123456",
        "CreationDate": "2025-08-04T12:00:00.000",
        "Status": 0
      },
      "OrderItems": [
        {
          "ReadOnly": {
            "OrderItemId": 1697381,
            "ItemIdentifier": { "Sku": "55HFL5214U/27", "Id": 52351 },
            "Qty": 5.0
          }
        }
      ],
      "SavedElements": []
    }
  }
}

Commonly used order fields:

data.ReadOnly.OrderId - The Extensiv order ID.
data.ReadOnly.ReferenceNum / data.ReadOnly.PoNum - The order's reference and PO numbers.
data.ReadOnly.CustomerIdentifier / data.ReadOnly.FacilityIdentifier - The customer and warehouse (Name + Id).
data.ReadOnly.Status - The order status code.
data.OrderItems[] - The order's line items, each with ItemIdentifier.Sku, quantities, and allocation flags.

Because Extensiv's notice fields vary by event type and by the resource involved, inspect the captured sample for the events you actually receive before mapping fields downstream. The event value identifies which event fired; branch on it when create, update, and lifecycle events should do different things.

Field shapes vary by event

Order, receipt, adjustment, assembly, item, and inventory events do not share a single fixed shape — each carries the body of its own resource type. Read the trigger output defensively, key on the resource identifier (e.g. the order or receipt ID under data.ReadOnly), and don't assume optional sections are present.

Example Usage & Common Use Cases

Sync a New Order into Another System

[Extensiv Trigger] → [Set: map order id / referenceNum / customer / status]
                       → [HTTP Request: upsert into TMS/ERP]

Generate EDI on Order Creation

Action: Order Create

[Extensiv Trigger] → [Set: extract order fields] → [EDI: build 940] → [AS2 / FTP: send to partner]

Confirm Shipment When an Order is Packed

Action: Pack Complete

[Extensiv Trigger] → [Set: map order / packages] → [EDI: build 945] → [AS2: send shipment confirmation]

React to Inventory Changes

Action: Inventory Summary Update

[Extensiv Trigger] → [If: on-hand below threshold] → [Send Email / create replenishment order]

Branch on Event Type

[Extensiv Trigger] → [Switch: on event]
                        ├─ OrderCreate  → [Create record]
                        ├─ OrderUpdate  → [Update record]
                        └─ OrderCancel  → [Void record]

How It Works

Extensiv posts an event - Extensiv sends a POST to the workflow's /hook/{workflowId} URL when a subscribed event occurs, carrying the event notice.
Verify (optional) - When Authentication is set to RSA, the inbound call is verified against the RSA credential before the workflow runs; with None, the POST is accepted as-is.
Match the trigger - The webhook ingress resolves the workflow and selects its trigger node.
Filter by action - The event's type (eventType) is checked against the Action selection; only enabled event types proceed.
Enqueue - Splice strips the resource body's _links / _embedded fields, builds the { event, data } envelope keyed by the node name, and starts a workflow execution.

Best Practices

Select only the events you handle - Enabling just the event types the workflow is built for avoids unnecessary runs.
Branch on the event type - The same node receives many event types; switch on the action/event so create, update, and cancel paths stay distinct.
Extract early - Map the handful of fields you need up front (e.g. order ID, reference number, status) so downstream nodes stay readable.
Make downstream actions idempotent - Update events can fire repeatedly for the same record; key downstream updates on the resource ID so repeats are safe.
Use RSA when the endpoint is exposed - If the public URL could receive untrusted calls, set Authentication to RSA so only signed Extensiv events start the workflow.
Guard against missing fields - Payload shapes differ by event and resource; don't assume a fixed structure.

Troubleshooting

Common Issues

No workflow runs on an Extensiv event - Confirm Extensiv's subscription points at the correct /hook/{workflowId} URL, the workflow is active, and the event type is enabled under Action.
Events are rejected - If Authentication is set to RSA, the inbound call must be signed with the key matching the RSA credential; a missing or mismatched signature is rejected. Switch to None (or correct the credential) to confirm where the failure is.
Workflow runs but data is missing - Extensiv notice fields vary by event type and resource. Inspect the captured trigger output for the actual shape and code defensively.

Debugging Tips

Inspect the captured sample - The trigger output is stored as node sample data on each run; use it to navigate the payload and build downstream field paths.
Test with a manual POST - Send a sample event body to the URL with curl to confirm the endpoint and downstream logic before relying on live Extensiv events (use Authentication: None while testing, or sign the request to match the RSA credential).

Webhook - The general-purpose HTTP trigger this node is built on
Extensiv - Call back into the Extensiv API when the workflow needs more than the event payload
Trigger Nodes - Overview of all available workflow trigger types

Overview​

Endpoint & Setup​

Authentication​

Configuration​

Action (required)​

Output​

Example Usage & Common Use Cases​

Sync a New Order into Another System​

Generate EDI on Order Creation​

Confirm Shipment When an Order is Packed​

React to Inventory Changes​

Branch on Event Type​

How It Works​

Best Practices​

Troubleshooting​

Common Issues​

Debugging Tips​

Related​