Shopify Average Order Value Trend Report with n8n

A Shopify average order value trend report in n8n turns raw order data into one number you can actually steer the store by, tracked week over week. This guide builds a workflow that pulls last week’s paid orders, computes average order value, compares it against the week before, logs the result to Google Sheets, and emails you the trend. It runs on a schedule, uses only free tools, and takes about 30 minutes to put together from scratch.

Prefer to skip the build? The guide below is free to follow. If you would rather not wire six nodes by hand, grab the ready-made template and import it in under ten minutes.

What it does

Average order value (AOV) is total revenue divided by number of orders. It tells you how much a typical customer spends per checkout, and it is one of the few metrics you can move directly with bundles, free-shipping thresholds, and upsells. The problem is that Shopify shows you today’s AOV but keeps no clean, owned history of how it moves, and it never emails you when the number slips.

This workflow fixes that. Once a week it asks the Shopify Admin API for every paid order in the last seven days and every paid order in the seven days before that. It sums the order totals, divides by the order count for each window, and calculates the change between them. It writes this week’s figures as a new row in a Google Sheet, so the trend line grows on its own, and it emails you a short summary that says whether AOV went up, down, or stayed flat versus last week.

The result is a self-updating AOV trend you own, sitting in your inbox every Monday morning, with a Google Sheet behind it that you can chart or hand to a bookkeeper. This is the analytics half of running a store on n8n Shopify automation: small scheduled reports that replace a spreadsheet chore you keep forgetting to do.

Why it beats the default

Shopify’s built-in Analytics does show an average order value tile, and on paid plans you can view it over a date range. So why build this?

• You own the history. Shopify’s dashboard is a live view, not a log you control. This workflow appends one row per week to your own Google Sheet, so you build a permanent trend that survives plan changes and export limits.
• It comes to you. Nobody logs into Analytics every Monday. An email that lands in your inbox with “AOV up 4.2% vs last week” gets read. A dashboard you have to remember to open does not.
• It is comparative by design. The default tile shows a number. This report always frames it against the prior week, which is the context that tells you whether a change is worth acting on.
• It is free and extendable. No third-party analytics app subscription. Because the math lives in a Code node, you can switch to net AOV, add a 4-week average, or split by sales channel later without paying anyone.

What you need

• An n8n instance (Cloud or self-hosted). Every node here is a core node, so there is nothing extra to install.
• A Shopify custom app access token. Create it through the 2026 Shopify Dev Dashboard and give it the read_orders scope. If you have not connected Shopify to n8n yet, follow connect Shopify to n8n (2026 method) first, then come back.
• A Google account for Google Sheets, to hold the trend log.
• A Gmail account to send the weekly report (or any email/Slack/Telegram node if you prefer another channel).

Estimated build time: about 30 minutes from scratch, or under 10 minutes with the template.

Node-by-node list

Six nodes, wired in a straight line. The Code node is where all the math happens, and it reads from both HTTP nodes by name.

[Every Monday 8am]  Schedule Trigger
        |
        v
[Fetch this week orders]  HTTP Request  -> Shopify Admin API, last 7 days, paid
        |
        v
[Fetch last week orders]  HTTP Request  -> Shopify Admin API, days 7-14, paid
        |
        v
[Compute AOV + trend]  Code  -> revenue / orders for each window, % change
        |
        v
[Append to AOV trend]  Google Sheets  -> one new row per week
        |
        v
[Email AOV report]  Gmail  -> "AOV up 4.2% vs last week"
  

Step-by-step build

Step 1 — Add the Schedule Trigger

Create a new workflow and add a Schedule Trigger. Set it to run weekly, on Monday, at 08:00. This gives you a clean seven-day window that always ends when the report runs. If your customers shop mostly on weekends, run it Monday morning so the previous week is complete.

Step 2 — Fetch this week’s paid orders

Add an HTTP Request node named Fetch this week orders. Configure it as a GET request to your Shopify Admin API:

URL:  https://YOUR_STORE.myshopify.com/admin/api/2026-04/orders.json
Auth: Predefined Credential Type -> Shopify Access Token API
Query parameters:
  status            = any
  financial_status  = paid
  created_at_min    = {{ $now.minus({ days: 7 }).toISO() }}
  created_at_max    = {{ $now.toISO() }}
  limit             = 250
  fields            = id,total_price,created_at

The fields parameter keeps the payload small by asking only for what the math needs. Using financial_status=paid means unpaid draft orders and pending checkouts never inflate the numbers.

Step 3 — Fetch last week’s paid orders

Add a second HTTP Request node named Fetch last week orders, identical to the first except for the date window:

  created_at_min = {{ $now.minus({ days: 14 }).toISO() }}
  created_at_max = {{ $now.minus({ days: 7 }).toISO() }}

This gives you the previous seven-day block, which is the baseline the report compares against. Wire it after the first HTTP node so both run before the math.

Step 4 — Compute AOV and the trend (Code node)

Add a Code node named Compute AOV + trend. It reads both HTTP nodes by name, sums each window, divides to get AOV, and builds both the sheet row and the email body:

const thisOrders = $('Fetch this week orders').first().json.orders || [];
const lastOrders = $('Fetch last week orders').first().json.orders || [];

function summarize(orders) {
  const revenue = orders.reduce((s, o) => s + parseFloat(o.total_price || 0), 0);
  const count = orders.length;
  const aov = count > 0 ? revenue / count : 0;
  return { revenue, count, aov };
}

const current = summarize(thisOrders);
const previous = summarize(lastOrders);
const delta = current.aov - previous.aov;
const pctChange = previous.aov > 0 ? (delta / previous.aov) * 100 : 0;
const direction = delta > 0 ? 'up' : delta < 0 ? 'down' : 'flat';

return [{ json: {
  report_date: $now.toFormat('yyyy-LL-dd'),
  orders_this_week: current.count,
  revenue_this_week: Number(current.revenue.toFixed(2)),
  aov_this_week: Number(current.aov.toFixed(2)),
  aov_last_week: Number(previous.aov.toFixed(2)),
  pct_change: Number(pctChange.toFixed(1)),
  direction
}}];

The count > 0 guard is what keeps a zero-order week from crashing the workflow. Notice the node never makes its own API calls; it just reaches back to the two HTTP nodes with $('Node Name'), which is why they must sit upstream on the same path.

Step 5 — Append the row to Google Sheets

Add a Google Sheets node named Append to AOV trend. Set the operation to Append, pick your spreadsheet and tab, and map the columns:

Date       = {{ $json.report_date }}
Orders     = {{ $json.orders_this_week }}
Revenue    = {{ $json.revenue_this_week }}
AOV        = {{ $json.aov_this_week }}
PctChange  = {{ $json.pct_change }}

Create a sheet with a header row of exactly Date, Orders, Revenue, AOV, PctChange before the first run. Each week adds one row, so after a few months you can select the AOV column and drop in a chart to see the trend at a glance.

Step 6 — Email the report with Gmail

Add a Gmail node named Email AOV report. Set the recipient to yourself, a subject like Weekly AOV report - {{ $json.report_date }}, and a short HTML body that reads the fields:

This week AOV: {{ $json.aov_this_week }}  ({{ $json.orders_this_week }} paid orders)
Last week AOV: {{ $json.aov_last_week }}
Trend: {{ $json.direction }}  ({{ $json.pct_change }}% vs last week)

Save the workflow and toggle it Active. That is the whole build: a scheduled AOV report that logs itself and emails you the direction of travel.

Common mistakes

• Forgetting the 250-order limit. A single Admin API call returns at most 250 orders. If a window holds more, you will undercount. Add cursor pagination with the Link header, or run the report more often on a shorter window.
• Counting the wrong orders. Leaving out financial_status=paid lets abandoned and unpaid draft orders slip in and drag AOV down. Keep the filter so you measure real revenue.
• Refunds not accounted for. total_price is the gross amount at checkout; a later refund does not change it. If you want net AOV, use current_total_price instead, which reflects refunds.
• Timezone drift. $now follows your n8n instance timezone. If that differs from your store's timezone, your seven-day window can start a few hours off. Set the instance timezone to match the store.
• Missing header row. If the Google Sheet has no header row that matches the mapped column names, the append silently writes to the wrong place. Add the header before the first run.

Cost at realistic volume

This report is effectively free to run. It fires four times a month and makes two Shopify API calls per run, which is nothing against Shopify's rate limits. Google Sheets and Gmail both sit inside their free tiers at this volume. The only real cost is your n8n instance, which you are already paying for if you self-host or run n8n Cloud.

Frequently asked questions

Related guides

• n8n Shopify automation — the pillar guide to every store workflow.
• Shopify profit margin tracker in Google Sheets — pair margin with AOV for the full picture.
• Shopify weekly best-sellers report — another scheduled report on the same pattern.
• Browse all n8n templates — ready-to-import workflows.
• More store automations in the Shopify category.