Shopify store backup automation with n8n (free and self-hosted)

Shopify store backup automation with n8n saves a nightly JSON snapshot of your products, orders, and customers to Google Drive, then logs each run to a Google Sheet and emails you a summary. It replaces backup apps that charge a monthly fee for the same data your store already exposes through the Admin API. You keep the files, the schedule, and the retention rules. Building it from scratch takes about 40 minutes.

Prefer to skip the setup? Grab the ready-made template and be running in under 10 minutes.

What it does

Shopify keeps your live data, but it does not hand you a full historical backup you control. If a bulk edit goes wrong, an app corrupts your catalog, or you ever need last month’s customer list, the platform will not give you a point-in-time copy. This workflow fills that gap.

Every night, n8n reads three datasets from your store through the Admin API: the full product catalog, all orders, and all customers. It bundles them into one dated JSON file, uploads that file to a Google Drive folder, appends a row to a running log sheet, and sends you a short confirmation email. The next morning you have a fresh, timestamped copy of everything, sitting in storage you own.

This is part of the broader pattern of connecting your store to a workflow engine. If you are new to it, start with our guide to n8n Shopify automation and come back here.

Why it beats the default

Most merchants handle backups in one of two ways, and both leave gaps.

The first is a paid backup app from the Shopify App Store. These work, but they charge a recurring fee that scales with your order volume, and your snapshots live inside a vendor’s account rather than yours. If that vendor changes pricing or shuts down, your safety net goes with it.

The second is manual CSV exports from the admin. This is free but partial. You export products one day, forget orders the next, and end up with a scattered pile of files that nobody dated properly. It relies on a human remembering to do a boring task on time, which is exactly the kind of task automation exists to remove.

The n8n version gives you the full three-dataset snapshot, on a fixed schedule, written to your own Drive, with a log you can audit. There is no per-record pricing, and you decide how long to keep each copy.

What you need

• An n8n instance, either n8n Cloud or a self-hosted install.
• A Shopify custom app access token with read scopes for products, orders, and customers. Follow our walkthrough on how to connect Shopify to n8n in 2026, which uses the current Dev Dashboard method and a modern Admin API version (2026-04).
• A Google account for Drive, Sheets, and Gmail, connected to n8n with OAuth.
• One Google Drive folder to hold the snapshots and one Google Sheet for the run log.

Estimated build time is 30 to 45 minutes from scratch, or under 10 minutes with the template.

How it works

The workflow fans out to three Shopify reads in parallel, waits for all of them to finish, then assembles and stores the snapshot.

┌──────────────────────────────────────────────────────────────┐
│  SHOPIFY NIGHTLY BACKUP                                       │
│                                                              │
│  [Schedule 02:00] ─┬─→ [Get all products] ─┐                 │
│                    ├─→ [Get all orders]   ─┤                 │
│                    └─→ [Get all customers]─┘                 │
│                                    ↓                         │
│                               [Merge (3)]                    │
│                                    ↓                         │
│                          [Build snapshot file]               │
│                                    ↓                         │
│              [Upload to Drive] → [Log to Sheet] → [Email]     │
└──────────────────────────────────────────────────────────────┘
  

Node-by-node list

Step-by-step build

1 Schedule the run

Add a Schedule Trigger node. Set the rule to a daily interval and pick a quiet hour such as 02:00. Overnight runs keep the backup away from busy checkout traffic and the daily API limits that come with it.

2 Read products, orders, and customers

Add three Shopify nodes, each connected directly to the Schedule Trigger so they run in parallel from a single trigger item. Configure them like this:

1. Node one: resource Product, operation Get Many, and turn on Return All so it pages through the entire catalog.
2. Node two: resource Order, operation Get Many, Return All on, and under options set Status to Any so cancelled and archived orders are included.
3. Node three: resource Customer, operation Get Many, Return All on.

Attach your Shopify Access Token credential to all three. Each node runs once and returns its full dataset.

3 Merge the three branches

Add a Merge node and set the number of inputs to 3. Connect each Shopify node to a separate input. Its only job is to pause the flow until all three reads have finished, so the next node does not run before the data is ready.

4 Build the snapshot file

Add a Code node running once for all items. It pulls each dataset by node name, wraps them in one object with a timestamp and record counts, and returns the result as an attached JSON file.

const products  = $('Get all products').all().map(i => i.json);
const orders    = $('Get all orders').all().map(i => i.json);
const customers = $('Get all customers').all().map(i => i.json);

const stamp = $now.format('yyyy-LL-dd');
const fileName = `shopify-backup-${stamp}.json`;

const snapshot = {
  generated_at: $now.toISO(),
  store: 'your-store.myshopify.com',
  counts: {
    products:  products.length,
    orders:    orders.length,
    customers: customers.length
  },
  products, orders, customers
};

return [{
  json: {
    file_name: fileName,
    date: stamp,
    products: products.length,
    orders: orders.length,
    customers: customers.length
  },
  binary: {
    data: {
      data: Buffer.from(JSON.stringify(snapshot, null, 2)).toString('base64'),
      mimeType: 'application/json',
      fileName
    }
  }
}];

After this node, one item carries both the plain counts and the ready-to-upload file:

{
  "file_name": "shopify-backup-2026-07-11.json",
  "date": "2026-07-11",
  "products": 214,
  "orders": 1863,
  "customers": 1592
}

5 Upload to Google Drive

Add a Google Drive node with operation Upload. Set the input binary field to data, and choose the destination folder you created for backups. Use the file name from the previous node so every upload keeps its date.

1. Operation: Upload.
2. File Name: ={{ $json.file_name }}
3. Input Binary Field: data
4. Parent Folder: select your Shopify Backups folder.

6 Log the run to Google Sheets

Add a Google Sheets node with operation Append. Point it at a log sheet and map the columns to the fields from the Code node. This gives you an audit trail you can scan at a glance.

7 Email the summary

Add a Gmail node with operation Send. Send yourself a short message so you know the backup ran without opening Drive.

Subject: Shopify backup complete — {{ $json.date }}

Products: {{ $json.products }}
Orders:   {{ $json.orders }}
Customers:{{ $json.customers }}
File:     {{ $json.file_name }}

The data structure

The Google Sheet log is deliberately simple. One row per night is enough to prove the backup ran and to spot a sudden drop in record counts that might signal a problem upstream.

Common mistakes

• Leaving Return All off on the Shopify nodes, which caps each dataset at 50 records and produces a backup that looks fine but is missing most of the store.
• Chaining the three Shopify reads one after another instead of running them in parallel into a Merge. Chaining makes the second read run once per record from the first, which multiplies API calls and can trip rate limits.
• Forgetting to set the Input Binary Field on the Drive node to data, which uploads an empty or wrong file.
• A mismatch between the Sheet header row and the mapped fields, which writes blank cells.
• Running on UTC when you meant local time, so the 02:00 backup lands in the middle of your business day.
• Granting the access token read scope for only one resource. It needs read access to products, orders, and customers, or the missing branch returns an error.

Cost at realistic volume

Take a store with 200 products, 1,800 orders, and 1,600 customers running one backup a night. Every service in the workflow sits inside a free tier at that scale.

A daily snapshot of a few megabytes adds up to roughly a gigabyte a year, well within the free Drive quota. Compared with a backup app that bills every month whether or not you ever restore, the running cost here rounds to zero.

Frequently asked questions

Related guides

• Connect Shopify to n8n in 2026, the credential setup this workflow depends on.
• Send new Shopify orders to Google Sheets for a live running order log.
• Bulk update Shopify prices from Google Sheets, a good reason to keep a backup handy.
• Browse every guide in the Shopify automation category.