Below is the Make scenario we build for that job, step by step. It works even if this is your first real scenario.
Short answer
Choose the table grain before mapping the order payload; the choice determines identifiers, iteration and totals. Define order-level or line-item-level reporting. Record refunds and order changes under a deliberate update policy. Before enabling the scenario, inspect the destination using a fictional input and compare the result with the intended business outcome.
Key facts
- Keep store and order identities in either layout.
- Customer email is not an order identifier.
- Do not add order totals once for each line item.
Need ready-made spreadsheets as well? The Flowpaja Sheets Bundle has 10 Google Sheets templates (bookkeeping, invoices, CRM, budgets and more) for $39.
What you need
- A Make.com account with a Shopify connection and a Google Sheets connection. No account yet? Create a free Make account (affiliate link).
- Access to your Shopify store's admin, so you can connect the store to Make.
- A Google Sheet with a header row (Step 2 shows the columns).
- Optional: a Slack workspace, if you want the order alert at the end.
Ad disclosure: links marked "affiliate link" are ads. If you sign up or buy through them, Flowpaja may earn a commission at no extra cost to you.
Connect Shopify to Make (do this first)
- In a new scenario, add a Shopify module, for example Watch orders. For an instant module such as Watch events, Make first asks you to Create a webhook, then to create the connection.
- Click Create a connection and keep the connection type Shopify.
- In Domain, enter only the first part of your store's
myshopify.comaddress. Forxyz.myshopify.com, enterxyz. Your custom domain (e.g.shop.example.com) won't work. You can find the address in Shopify admin under Settings → Domains. - Click Save. Shopify opens and asks you to install the Make app and approve its access to your store data. Click Install.
Who can do this: Make requires a paid Shopify plan. In Shopify, the store owner can install the app. So can a staff member with the Manage and install apps and channels permission, as long as they also have the permissions the app needs, such as viewing orders.
One connection per store. Make's docs warn against creating several connections for the same Shopify app and store. The last one you create overwrites the scopes of both, across all Make organizations and teams. Reuse the one connection in every scenario for that store.
Custom app connections: Make also offers a Shopify (Custom app) connection that uses an Admin API access token. Since 1 January 2026, Shopify no longer lets you create new custom apps in the Shopify admin. Existing ones keep working, and new ones have to be built in Shopify's Dev Dashboard. For a new setup, the standard connection above is simpler.
Two Shopify data limits to know:
- By default, apps can read orders from the last 60 days. Older orders need the
read_all_ordersscope, which Shopify has to approve. New orders aren't affected. This only matters if you want to backfill old orders. - Protected customer data (such as name, email, phone and address) can come back empty if the app doesn't have Shopify's approval for those fields. Check your first test order: if the Customer email column is empty while the order in Shopify has an email, the cause is data access, not your mapping. Only copy the personal data you actually need into Sheets or Slack.
| Problem | Likely cause | Fix |
|---|---|---|
| Connection fails | Full or custom domain entered | Enter only xyz from xyz.myshopify.com |
| Can't install the Make app | Staff account lacks app permissions | Ask the store owner, or get Manage and install apps and channels |
| Shopify modules in another scenario start failing after a new connection | A second connection for the same store overwrote the scopes | Keep one connection per store; reauthorize it |
| Orders older than 60 days missing | Shopify's default 60-day window | Expected; export old orders from Shopify instead |
| Customer fields empty | Protected customer data | Map only the fields that come through |
Decide first: one row per order, or one row per line item?
Answer this before you touch Make, because it changes the whole sheet.
- One row per order is right when you care about revenue, customers and order status. Order #1042 is one row, with the products squeezed into a single "Items" cell.
- One row per line item is right when you care about products: stock planning, supplier reorders, which SKU sells with which. Order #1042 with three products becomes three rows that share the same order number.
Need both? Use two tabs fed by the same scenario.
Step 1: Choose the trigger: Watch orders or Watch events
The Shopify app in Make gives you two realistic ways to start.
Shopify > Watch orders is a polling trigger. Make checks your store on the scenario's schedule (every 15 minutes, every hour, whatever you set) and pulls in orders it hasn't seen yet. Easiest to set up. Two things to know:
- It is not instant. An order placed at 10:01 might land in the sheet at 10:15.
- Every scheduled check uses credits, even when there are no new orders. A 5-minute schedule on a quiet store burns credits on empty runs.
Shopify > Watch events is the instant, webhook-based trigger. Shopify pushes the order to Make the moment the event happens. You pick a Shopify webhook topic such as orders/create, orders/paid, orders/cancelled or refunds/create (Make may list them in Shopify's enum style, for example ORDERS_CREATE). The trade-off: each trigger listens to one topic, and if Shopify sends the same event twice (it retries when a delivery isn't acknowledged), you need your own duplicate check. More on that in Step 5.
Our default: Watch events on orders/paid if the sheet is used for accounting, orders/create if it's used for fulfilment. Watch orders only when the client wants the simplest possible setup and doesn't mind the delay.
One gotcha with Watch orders: it remembers where it stopped. If you click "Run once" twice while testing, the second run often returns nothing. Right-click the module and choose where to start from, or place a fresh test order.
Step 2: Prepare the sheet
Create the header row before you build the Google Sheets module, so Make can read the columns. A setup that holds up for order-level logging:
| Column | Source field |
|---|---|
| Order ID | id |
| Order number | name (e.g. #1042) |
| Created | created_at |
| Customer email | email |
| Total | total_price |
| Currency | currency |
| Payment status | financial_status |
| Fulfilment status | fulfillment_status |
| Items | built with a formula (below) |
| Status | written by the refund/cancel scenario |
Keep Order ID in column A. It's the key everything else depends on. The order number (#1042) looks nicer, but the numeric ID is what Shopify uses in refund and cancellation payloads. The source fields are the names in Shopify's order webhook payload, which is what Watch events delivers. Watch orders can label some of them differently, so pick them in the mapping panel.
Step 3: Map the fields (one row per order)
Add Google Sheets > Add a Row, pick the spreadsheet and the tab, set "Table contains headers" to Yes, and the columns appear as fields.
Map most of them directly. A few need a function:
- Created:
formatDate(1.created_at; "YYYY-MM-DD HH:mm"; "Europe/London"). Replace the time zone with your store's. Raw ISO dates sort fine but are hard to read. - Total: Shopify sends prices as text. If you want the sheet to sum them, use
parseNumber(1.total_price; ".")or set the column format to number in Sheets. - Items:
join(map(1.line_items; "title"); ", ")gives you "Linen shirt, Canvas tote" in one cell. Want quantities? Use an Iterator plus Tools > Text aggregator with{{quantity}} × {{title}}and map the aggregated text. - Fulfilment status is empty on unfulfilled orders. Wrap it:
ifempty(1.fulfillment_status; "unfulfilled").
Run it once with a real test order and check every column.
Step 4: One row per line item with Iterator
For product-level logging, add Flow Control > Iterator between the trigger and the Sheets module, and map line_items[] into its Array field. Each product in the order now becomes its own bundle.
In the Add a Row module, map order fields from the trigger (order number, date, email) and product fields from the Iterator (title, variant_title, sku, quantity, price). Add a Line item ID column and map the Iterator's id. Order ID plus line item ID is your unique key here.
A note on credits: every bundle that passes through Add a Row costs credits, so a 10-item order means 10 runs of that module. If your orders are large, replace Add a Row with an Array aggregator (source module: the Iterator) followed by Google Sheets > Bulk Add Rows (advanced). One write per order instead of one per item, and you're far less likely to hit Google's rate limits during a sale.
Step 5: Stop duplicate rows (search before you add)
Duplicates come from three places: webhook retries, someone re-running the scenario, and a Watch orders trigger reset to an earlier point. The fix is the same: check before you write.
The obvious approach is Google Sheets > Search Rows filtered on Order ID, then add a row only if nothing was found. The catch: when Search Rows finds nothing, the route doesn't stop. It outputs one empty bundle (no row data, no Row number, Total number of bundles = 0), and the next module still runs once. So you have to branch on the result yourself.
Two ways around it:
- Router on Total number of bundles. Set the search's Limit to 1 and add a Router right after Search Rows. Route 1 has the filter Total number of bundles, Equal to (number), 0 → Add a Row, with the values mapped from the order (the trigger), not from Search Rows. Route 2 has Total number of bundles Greater than 0 → Update a Row (using Search Rows' Row number) or just stop. Don't put an Array aggregator in between: it receives the empty bundle and outputs an array with one empty item, so
length(Array) = 0never matches. - Data store. Create a Make data store keyed by Order ID. Use Data store > Check the existence of a record before writing; it returns a yes/no you can filter on. After writing the row, Add/replace a record. It's faster than searching a large sheet.
For line-item mode, search on Order ID + Line item ID, or check the order once before the Iterator so you skip the whole order if it's already there.
Step 6: Handle refunds and cancellations
Don't delete rows when an order is refunded. Deleted rows break totals people already reported. Update the row instead.
Build a second, small scenario:
- Shopify > Watch events with topic
refunds/create(and a copy withorders/cancelled). - Google Sheets > Search Rows on Order ID. For refunds, the ID is in the payload's
order_id; for cancellations, it's the order's ownid. - Google Sheets > Update a Row using the found row number: set Status to "Refunded", "Partially refunded" or "Cancelled", and write the refund amount into its own column. Partial refunds are common, so don't overwrite the original total.
If a cancelled order was never logged, the search finds nothing and the scenario ends quietly.
Step 7: Add a Slack alert
Add Slack > Send a message (formerly Create a Message) at the end of the main scenario. Don't alert on every order; people mute that channel within a week. Put a filter on the route instead:
- order total above a threshold you choose,
- orders with a customer note (
noteis not empty), - or a specific product or shipping method.
A useful message: New order {{1.name}}, {{1.total_price}} {{1.currency}}, {{1.email}} plus a link to the order in your Shopify admin.
Error handling that actually helps
Right-click a module and choose Add error handler:
- On the Google Sheets module, use Retry (formerly Break) with automatic retries. Google returns rate-limit errors during busy hours, and a retry a few minutes later almost always succeeds.
- On the Slack module, use Skip (formerly Ignore). A failed alert shouldn't mark the run as an error when the row was written.
- Resume is handy when a lookup fails and you'd rather write a fallback value ("unknown") than stop.
- Commit and Rollback only matter for modules that support transactions, such as data stores. Google Sheets writes can't be rolled back, which is one more reason to check for duplicates first.
Also turn on Store incomplete executions in the scenario settings, so a failed order waits for you instead of vanishing; Retry needs it. One more reason to handle errors: by default Make switches a scenario off after 3 errors in a row, and a scenario that starts with an instant trigger such as Watch events is switched off after the first one.
Place test orders without real customers
Don't test with real customers or real cards. Shopify gives you three ways:
- Shopify Payments test mode: turn on test mode and pay with Shopify's test card details. While any payment provider is in test mode, customers can't place live card orders. Test at a quiet time and switch test mode off when you're done.
- Shopify's Test payment gateway, if you don't use Shopify Payments. Test orders don't show in payouts or reports. You can only test a payment gateway after choosing a paid plan.
- A draft order marked as paid: create a draft order for a fictional customer such as "Test Buyer" with your own email address, then mark it as paid. That turns it into a regular order without any payment. Cancel it after the test, which also tests the cancellation scenario from Step 6.
Run the scenario once and check the output: order name (e.g. #1001), order ID, total, currency, the line items, and whether the customer fields came through.
Quick test checklist
- Place a test order with two different products and check both tabs.
- Re-run the same bundle and confirm no second row appears.
- Refund one item and check that the Status and refund columns update.
- Cancel an unpaid order and confirm nothing breaks.
- Check the scenario history after a day to see what you're spending in credits.