Zapier shipping automation architecture

How the Zaps interact with the Genius API

The shipping automation crosses five boundaries: WooCommerce stores, a WordPress snippet, the visible Zap, a private Zapier app called Genius ERP, and the Genius REST API. The key split is that the visible Zap coordinates the workflow while the private app handles the actual Genius login and shipping lookup.

WooCommerce sites PetStep, HandiTreads, GetBiggies, HandiRamp, and CargoVanRamps expose candidate processing orders.

WordPress snippet Genius<-> WC via Zapier Functions registers /wp-json/genius/v1/gen-orders.

Visible Zap Runs once daily at 5:00 AM Central, merges store results, builds the PO array, parses results, and writes back tracking.

Private app Genius ERP, app id 225816, package [email protected].

Genius call POST /api/data/entities/ShippingHeaderEntity/PoNumber with a bearer token.

Business result Carrier, ship method, tracking number, shipping date, Genius SO, and shipping code written back to WooCommerce.

Executive version

WooCommerce provides the order queue and receives customer-service-ready tracking metadata. Zapier is the scheduler and coordinator. Genius is the source of truth for whether a web order has shipped.

The important detail is the trust boundary: the WordPress snippet exposes only authorized WooCommerce order data, the visible Zap mostly passes order references around, and the private Zapier app handles the Genius login and API request. That keeps the Genius-specific implementation in one reusable place instead of scattering raw calls across many Zap steps.

1. WooCommerce finds candidates Processing orders without tracking are exposed through the WordPress gen-orders endpoint.

2. Visible Zap coordinates The Zap merges order rows, preserves the site URL and order ID, and builds the Genius PO list.

3. Private app crosses the trust boundary The custom Genius ERP Zapier app handles Genius auth and the bulk shipping lookup. WooCommerce auth is retrieved from Zapier Storage.

4. Genius returns shipping data ShippingHeader matches come back with PO, SO code, shipping code, ship date, and package JSON.

5. WooCommerce gets the writeback Zapier writes gen_* tracking metadata, completes the order, and logs the outcome.

Simplified explanation

1. Find open web orders

Once daily at 5:00 AM Central, the Zap asks each store's gen-orders endpoint for recent processing orders that do not already have gen_tracking. The WordPress snippet returns order IDs, site URLs, and wc_po = WEB-{order_id}.

2. Ask Genius in bulk

Zapier collects the PO values and sends them to the private Genius ERP app action. The visible Zap step only passes a PO array; the custom app handles the real Genius API request.

3. Write tracking back

If Genius returns package data, Zapier parses the carrier and tracking number, then updates the matching WooCommerce order and marks it completed.

Detailed sequence

Zapier schedule starts the workflow. The inspected published Zap runs once daily at 5:00 AM Central. Raw Frequency Type = 3 means daily; the interval field is 1.

The Zap computes the lookback window. A Formatter step creates a timestamp 7 days before the Zap run in YYYY-MM-DDTHH:MM:SS format.

The Zap pulls candidate orders from each WooCommerce site. Webhook POST steps call /wp-json/genius/v1/gen-orders with status=processing, gen_tracking=!, limit=100, and modified_after.

The WordPress snippet filters and returns the order rows. The snippet is installed as Genius<-> WC via Zapier Functions, requires edit_shop_orders, caps results at 100, and returns site_url, order fields, product SKUs, and current gen_* metadata.

The Zap merges order responses. A code step combines the store responses into one orderArray, then extracts the wc_po values.

The private Genius app authenticates to Genius. Zapier Session Auth posts CompanyCode, Username, and Password to /api/auth. Genius returns a token as Result.

The private app calls the Genius shipping lookup endpoint. The action gen_bulk_shipping_check posts the PO array to /api/data/entities/ShippingHeaderEntity/PoNumber using Authorization: Bearer bundle.authData.Result.

Genius returns matching shipping headers. The Zap uses PoNumber, Code, SalesOrderHeaderCode, Note, and ShippingDate.

The Zap parses the package JSON. When Note contains pkgdata, the Zap parses JSON.parse(Note).pkgdata[0] for carrier, ship method, and tracking ID.

The Zap updates the WooCommerce order. After a queue delay, Zapier retrieves the site-specific WooCommerce auth value and sends a PUT to /wp-json/wc/v3/orders/{order_id}.

The Zap logs the outcome. Successful updates and errors are written to Google Sheets and Zapier Tables, then the follow-up gen_Daily Email Order Report Sub-Zap sends the daily email report.

The visible Zap does this

The Zapier editor mostly shows orchestration: schedules, Formatter steps, Webhooks to WooCommerce, code steps, filters, delays, and WooCommerce update calls.

WooCommerce orders missing tracking
  -> call each site's /wp-json/genius/v1/gen-orders endpoint
  -> snippet returns order rows with wc_po = WEB-{order_id}
  -> merge into orderArray
  -> extract orderArray[]wc_po
  -> call Genius ERP action: gen_bulk_shipping_check
  -> parse returned Note.pkgdata[0]
  -> PUT tracking fields back to WooCommerce

This is why the visible Zap can look like it is not calling Genius. The raw Genius call is hidden behind the custom app action.

The private Genius app does this

The custom Zapier app is the Genius connector. Its authentication screen and action configuration are in the Zapier Developer Platform, not in the normal Zap editor.

Session Auth:
POST https://handiproducts.geniuserpcloud.com:53215/api/auth
body: CompanyCode, Username, Password
token returned as: bundle.authData.Result

Bulk shipping action:
POST /api/data/entities/ShippingHeaderEntity/PoNumber
Authorization: Bearer {{bundle.authData.Result}}
body: array of PO numbers

The saved App Connections page manages account connections. The editable API implementation lives under Developer Platform app 225816.

The WordPress snippet does this

Holly's spreadsheet confirms the Zap-facing WooCommerce layer is a WordPress snippet called Genius<-> WC via Zapier Functions. It registers shipping metadata fields and exposes the order search endpoint Zapier uses.

Endpoint:
/wp-json/genius/v1/gen-orders
methods: GET, POST
permission: current_user_can('edit_shop_orders')

Common Zap filters:
status=processing
gen_tracking=!
limit=100
modified_after={{7-day lookback timestamp}}

Returned matching key:
wc_po = WEB-{order_id}

The spreadsheet's Platform UI snippets include older GET/filter examples. The live private Zapier app inspected on 2026-08-03 uses the POST bulk action documented below.

Credentials and daily email report

Where credentials live

There are two credential layers. WooCommerce REST auth values are seeded by step 3, Store Creds 'securely', into Zapier Storage and later retrieved by site URL before the WooCommerce PUT update. Genius credentials live in the private Genius ERP (1.0.1) HANDIP App Connection and are exchanged through Zapier Session Auth at /api/auth.

No live credential values are documented here. Zapier Storage is convenient, but it is not the same thing as a dedicated secret manager; access to the Zap should be treated as sensitive.

What the Sub-Zap does

Parent Zap calls to Sub-Zap 307302958 run gen_Daily Email Order Report. It receives a source value such as has shipdata, !shipdata, or order_update_error, queries Zapier Table 01JWW5V7DF1BWG38J6Q00YFTPF, builds an HTML order table, and sends an Email by Zapier report.

The published Sub-Zap prints the source in the email, but its table query filters by gen_tracking is null, fetched_at >= yesterday, and reported == false, not by source.

Confirmed private app configuration

Item	Value	Why it matters
Developer app	`https://developer.zapier.com/app/225816`	This is where the Genius API implementation is edited.
Integration name	`Genius ERP`	The private Zapier app wrapping Genius auth and API calls.
Active package	`[email protected]`	This is the package currently used by the inspected shipping Zap.
Shipping action	`Shipped Orders, Bulk` / `gen_bulk_shipping_check`	This is the action that receives WooCommerce PO numbers and returns Genius shipping headers.
Auth scheme	Zapier Session Auth	Zapier logs into Genius and stores the returned token for the action call.
Production connection	`Genius ERP (1.0.1) HANDIP`, connection id `57028114`	The HANDIP Genius connection used by multiple Zap workflows.
Proto connection	`Genius PROTO #3`, connection id `56249611`	Safer test connection for future app-version testing.

Secret credential values are intentionally not documented here.

Exact Genius action code shape

This is the confirmed shape of the private Zapier action inspected in the Developer Platform. It receives a JSON array of PO numbers from the Zap, posts that array to Genius, and returns the Result array.

const options = {
  url: 'https://handiproducts.geniuserpcloud.com:53215/api/data/entities/ShippingHeaderEntity/PoNumber',
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Accept': 'application/json',
    'Authorization': `Bearer ${bundle.authData.Result}`
  },
  body: JSON.parse(bundle.inputData.gen_po_array),
}

return z.request(options)
  .then((response) => {
    const results = response.json;
    const resultArray = results.Result;
    return resultArray;
  });

This is different from Order Lookup. Order Lookup uses PHP cURL on WPEngine. This Zap uses Zapier's private app runtime and z.request().

Data fields passed through the workflow

Field	Source	Meaning in the Zap
`wc_po`	WooCommerce store endpoint	The order reference Zapier sends to Genius as the PO lookup key.
`PoNumber`	Genius `ShippingHeaderEntity`	The Genius-side PO number matched against the WooCommerce PO.
`Code`	Genius `ShippingHeaderEntity`	Stored back as `gen_shcode`, the Genius shipping code.
`SalesOrderHeaderCode`	Genius `ShippingHeaderEntity`	Stored back as `gen_sohcode`, the Genius sales order number.
`Note`	Genius `ShippingHeaderEntity`	Raw JSON text containing `pkgdata`, including carrier and tracking details.
`ShippingDate`	Genius `ShippingHeaderEntity`	Written back to WooCommerce as `gen_shipdate`.
`pkgdata[0].carrier`	Parsed from Genius `Note`	Written back as `gen_carrier` and used to build the tracking link.
`pkgdata[0].trackingID`	Parsed from Genius `Note`	Written back as `gen_tracking`.

WooCommerce fields updated

When a matching Genius shipping record contains package data, the Zap writes a shipping snapshot back to the matching WooCommerce order and changes the order status to completed.

gen_carrier   -> carrier parsed from Genius Note.pkgdata[0]
gen_updated   -> timestamp/update marker
gen_method    -> ship method parsed from Genius Note.pkgdata[0]
gen_tracking  -> tracking ID parsed from Genius Note.pkgdata[0]
gen_tracklink -> generated FedEx, USPS, or UPS tracking URL
gen_sohcode   -> Genius SalesOrderHeaderCode
gen_shcode    -> Genius ShippingHeaderEntity.Code
gen_po        -> Genius PoNumber
gen_json      -> raw Genius Note JSON
gen_shipdate  -> Genius ShippingDate
status        -> completed

Where to access or edit it

Credentials and saved accounts

Go to Zapier App Connections and open Genius ERP (1.0.1) HANDIP for the Genius side. That screen lets users rename, share, test, replace, change owner, or delete the saved Genius connection.

WooCommerce site auth is separate: it is stored/retrieved through the Zap's Storage by Zapier steps.

API implementation

Go to https://developer.zapier.com/app/225816/version/1.0.1, then Build -> Actions -> Shipped Orders, Bulk -> API Configuration.

Authentication is under Build -> Authentication.

Do not casually save edits to version 1.0.1. Live workflows use this version. Safer change path: create a new app version, test with the PROTO connection, then migrate selected Zaps after the new version is proven.

Known audit notes

Lookup window

The visible Zap pulls up to 100 processing orders per site from the last 7 days. Delayed shipments or unusually busy periods can be missed unless the store endpoint handles pagination internally.

Package parsing

The Zap currently parses pkgdata[0]. If Genius stores multiple packages, secondary tracking numbers may not be written back.

PO matching

Matching is based on the first web order with the same wc_po. Duplicate PO values across sites or channels can create wrong-order update risk.

Documentation drift

Holly's Sheet is right on the 5:00 AM daily schedule. Its Platform UI snippets still show older GET/filter examples; the live private app action uses the POST endpoint shown above.

Sub-Zap return value

The published email-report Sub-Zap has an automatic issue on its return step: it references a missing step ID. The outbound email behavior is clear; the return payload should be treated as suspect.

Related explainers

This page explains the Zapier automation path. For the separate browser-based Order Lookup path, see How Order Lookup Accesses Genius API and PHP cURL and REST over HTTPS Explained.