How to Automate Shopify Orders to Google Sheets Using Make.com

Introduction

If you run an online store, the manual version of this is painfully consistent: you open Shopify, find new orders, copy key fields into Google Sheets, and hope you do not create duplicates when an order updates, payment status changes, or the same order event fires again.

This is a classic Cross-Platform Automation (XPA) problem. Your spreadsheet becomes a “latest snapshot” that drifts over time, because the process is human and retries happen.

In this post you will build a simple Shopify to Google Sheets XPA in Make.com that deduplicates by Shopify order ID, creates a row once, and then updates that row when the same order changes.

What You'll Need

• Shopify store
• Google Sheets spreadsheet with edit access
• Make.com account
• A sheet tab with a stable key column, recommended columns:
  • order_id
  • created_at
  • customer_email
  • customer_name
  • order_name
  • financial_status
  • fulfillment_status
  • currency
  • total_price
  • line_items_summary
  • updated_at

No special paid requirements are implied for the conceptual flow, but your Shopify access method may depend on the Shopify trigger choice you use in Make.

How It Works (The Logic)

When a Shopify order event fires [Shopify trigger], Make.com receives the order data, extracts the fields you care about, then runs a Google Sheets Search Rows lookup by order_id.

• If the order ID is not found, Make adds a new row in Google Sheets.
• If the order ID is found, Make updates the existing row with the latest statuses and totals.

Trigger → Normalize fields → Google Sheets lookup (by order_id) → Router (exists vs not found) → Add row or Update row.

Step-by-Step Setup

1) Create the Make.com scenario

• In Make.com, create a new Scenario.
• Name it: Shopify → Google Sheets (Orders).

2) Add the Shopify trigger

Choose a Shopify trigger that fits your intent:

• If you want “new orders” captured as they appear, use a new order style trigger.
• If you only care about revenue-relevant events, choose the paid/relevant trigger your Shopify connection exposes in Make.

For a simple build, the important part is that Make will send you a payload containing:

• order ID
• order name/number
• created timestamp
• customer email and name
• financial and fulfillment status
• totals, currency
• line items (or enough data to summarise them)

3) Map and normalize the fields you will write

Add a data mapping step (or just map directly in later modules) so your downstream logic uses consistent names.

Map these into variables:

• order_id
• order_name (often the order number or display name)
• created_at
• customer_email
• customer_name
• financial_status
• fulfillment_status
• currency
• total_price

For line_items_summary, you have two pragmatic options for a simple sheet:

• Join item names and quantities into one string (example: T-Shirt x2, Socks x3)
• If you do not want item detail, store just a count and total item names, like 3 items

4) Add Google Sheets: Search Rows (dedupe)

• Add Google Sheets → Search Rows.
• Spreadsheet: your target file
• Tab: Orders
• Search key: order_id
• Search value: the incoming Shopify order_id

This step answers the question: “Do we already have this order in the sheet?”

5) Add a Router: exists vs not found

Immediately after Search Rows, add a Router.

• Route A: matching row found (exists)
• Route B: no matching row found (not found)

Gotcha: Router conditions must be based on the search result count/output, not on whether a variable is “present”. If you route incorrectly, you will get duplicates.

6) Build the “not found” branch: Add a row

In the not found branch:

• Add Google Sheets → Add a row.
• Write columns:
  • order_id = Shopify order ID
  • created_at = Shopify created timestamp
  • customer_email
  • customer_name
  • order_name
  • financial_status
  • fulfillment_status
  • currency
  • total_price
  • line_items_summary
  • updated_at = current time in Make

7) Build the “exists” branch: Update the existing row

In the exists branch:

• Add Google Sheets → Update a row.
• Use the row identifier returned by the Search Rows step.
• Update these columns with the latest values:
  • financial_status
  • fulfillment_status
  • total_price
  • currency
  • line_items_summary
  • updated_at

Gotcha: Only update what can change. Keeping created_at stable helps debugging. The most important thing is updating the existing row using the correct row number or row ID from the search output.

8) Test with a new order, then force an update

Do two test runs:

1. Create a new Shopify order that triggers Make.
   • Confirm Google Sheets gets exactly one new row.
2. Trigger another event for the same order (common examples: payment changes, fulfillment changes, or a re-delivery depending on your Shopify trigger behavior).
   • Confirm it updates the same row instead of creating a second row.

9) Turn it on and sanity-check the first day

• Enable the scenario.
• Watch execution history for:
  • lookup mismatches (search uses order_id but your mapping writes a different value)
  • duplicate rows (router or dedupe key issue)
  • blank customer email fields (depends on Shopify customer data and guest checkout)

Real-World Business Scenario

A UK D2C brand used Shopify for orders and Google Sheets for weekly ops reporting. Their manual workflow broke when Shopify sent repeated order events, causing duplicate rows and incorrect totals.

After implementing this Shopify to Google Sheets XPA in Make.com, every order ID created one row, then order updates refreshed statuses and totals in the same row. Their ops team stopped cleaning the sheet every Monday because the sheet matched Shopify.

Common Variations

• Only capture paid orders: switch the Shopify trigger to a “paid” style event so your sheet is revenue-first.
• Add Slack notifications for specific statuses: after the Update row step, post to a Slack channel only when financial_status becomes paid.
• Write line items to a separate tab: if you need per-item reporting, keep Orders for order-level fields and create a second tab like Order Line Items using an iterator in Make.

Keeping scheduling and reporting aligned

You built a simple Shopify to Google Sheets Cross-Platform Automation (XPA) in Make.com: Shopify triggers, Make deduplicates by order ID, then Google Sheets either adds or updates a row.

If you want this adapted to your exact Shopify order lifecycle, your Google Sheets schema, or your preferred notification flow, Olmec Dynamics builds these automations for real teams. You can see what we do here and revisit Cross-Platform Automation (XPA).

Internal notes: no related Olmec Dynamics posts were found to link for this exact Shopify to Google Sheets topic in the internal search step.