Make.com + Shopify: E-Commerce Automation Without Code

Contains affiliate links. Disclosure.

Every Shopify order that arrives triggers a cascade of tasks: send a confirmation email, update the inventory count, push a row into the accounting spreadsheet, notify the warehouse, and tag the customer for future segmentation. Done manually, that's 15–20 minutes per order. At 50 orders a day, it's a full-time job.

Make.com connects to Shopify via a native module that watches for events in real time and routes data to any downstream app — no code required. This guide covers four high-value automation patterns with three copy-paste scenario blueprints you can deploy today.

Why Make.com for Shopify Automation?

Shopify's own automation tool, Shopify Flow, is powerful inside the Shopify ecosystem but stops at the Shopify boundary. It can't push data to QuickBooks, Slack, or a Google Sheet without a third-party app.

Make.com solves the cross-app problem. It connects Shopify to over 1,800 applications on a single visual canvas. Key advantages over alternatives:

Tool	Shopify Triggers	Cross-App Routing	Pricing Model	Best For
Make.com	✅ Real-time webhooks	✅ 1,800+ apps	Operations-based	Multi-app workflows, visual logic
Shopify Flow	✅ Native events	❌ Shopify only	Included with Shopify	Internal Shopify logic
Zapier	✅ Polling or webhook	✅ 6,000+ apps	Task-based	Simple 1-to-1 automations
n8n	✅ Webhook	✅ Unlimited via code	Self-hosted free	Developers needing code-level control

Make.com's operations-based pricing (you pay per operation across all scenarios, not per task per Zap) makes it significantly cheaper than Zapier at scale. See current Make.com plans →

Connecting Make to Your Shopify Store

Before building scenarios, complete the one-time connection:

1. In Make.com, create a new scenario and search for the Shopify module.
2. Add any Shopify trigger (e.g., Watch Orders) and click Add a connection.
3. Enter your Shopify store URL (e.g., yourstore.myshopify.com) and click Save.
4. Make redirects you to your Shopify admin to approve the OAuth connection.
5. After approval, select your store from the dropdown and click OK.

Make will automatically register a webhook in your Shopify store. New events (orders, inventory updates, customer changes) now fire in real time — no polling delay.

---

Blueprint 1: Order Processing Automation

What it does: Every new Shopify order triggers fulfillment, a customer email, and an accounting entry — simultaneously.

Operations per run: ~5 (well within every Make plan)

Scenario structure

Shopify: Watch Orders (Trigger)
  ↓
Router (splits into 3 parallel branches)
  ├── Branch A: Shopify → Fulfill Order (mark as fulfilled)
  ├── Branch B: Gmail / SMTP → Send Email (order confirmation)
  └── Branch C: Google Sheets → Add Row (accounting log)

Step-by-step setup

Trigger — Watch Orders:

1. Add module: Shopify → Watch Orders.
2. Set Event type to New Order.
3. Set Limit to 10 (processes up to 10 new orders per scenario run).

Branch A — Fulfill the order:

1. Add module: Shopify → Create a Fulfillment.
2. Map Order ID from the trigger output.
3. Set Notify Customer to true if you want Shopify's native fulfillment email.

Branch B — Send confirmation email:

1. Add module: Gmail → Send an Email (or SMTP for custom domain).
2. To: Map {{1.email}} (the 1 refers to module 1 — the Shopify Watch Orders trigger).
3. Subject: Your order #{{1.order_number}} is confirmed.
4. Content: Use Make's HTML editor to build a branded template. To list all ordered products, add an Iterator before the email step to loop through {{1.line_items[]}}, then reference {{iterator.title}} in the email body. This ensures each product appears on its own line rather than as a raw array string.

Branch C — Log to Google Sheets:

1. Add module: Google Sheets → Add a Row.
2. Map columns: Order ID, Customer Name, Total Price, Created At, Payment Status.
3. This creates a running revenue log useful for daily reconciliation or importing into accounting software.

Upgrade path: Replace Google Sheets in Branch C with QuickBooks → Create a Sales Receipt or Xero → Create an Invoice for direct accounting integration.

---

Blueprint 2: Inventory Sync with Suppliers

What it does: When a product's Shopify inventory falls below a threshold, Make automatically sends a reorder request to your supplier (via email or a supplier portal API) and logs the event.

Operations per run: ~4

The problem with manual reordering

Stockouts cost Shopify merchants an average of 10–15% of potential monthly revenue. Manual stock checks are error-prone. The fix is a scheduled scenario that reads inventory levels and triggers reorders automatically.

Scenario structure

Schedule: Every 6 hours (Trigger)
  ↓
Shopify: Get Inventory Levels
  ↓
Iterator: Loop through each product variant
  ↓
Filter: quantity < reorder_threshold
  ↓
Router
  ├── Branch A: Gmail → Email supplier reorder request
  └── Branch B: Google Sheets → Log reorder event

Step-by-step setup

Trigger — Scheduled check:

1. Use the Schedule trigger (clock icon in Make).
2. Set interval to every 6 or 12 hours depending on your sales velocity.

Get inventory levels:

1. Add module: Shopify → Get Inventory Level.
2. Set Location ID to your warehouse location (find this in Shopify Admin → Settings → Locations).

Iterator + Filter:

1. Add an Iterator to loop through the array of inventory items returned.
2. After the iterator, add a Filter (the wrench icon on the connector line).
3. Condition: {{inventory_item.available}} < 20 (adjust your threshold).

Supplier email:

1. Add module: Gmail → Send an Email.
2. To: Your supplier's purchase order email.
3. Subject: Reorder Request: {{inventory_item.sku}} — {{inventory_item.product_title}}
4. Body: Include SKU, product name, current quantity, and requested reorder quantity.

For supplier portals with an API: Replace the Gmail step with an HTTP → Make a Request module. POST to your supplier's API endpoint with the SKU and quantity fields. This is fully no-code — Make's HTTP module handles authentication headers, JSON body construction, and response parsing.

---

Blueprint 3: Competitor Price Monitoring → Dynamic Shopify Pricing

What it does: An Apify scraper runs on a schedule, extracts competitor prices, Make compares them to your Shopify prices, and automatically adjusts your prices or flags items for manual review.

Operations per run: ~8–12 (depending on product catalog size)

This is the most powerful of the three blueprints because it closes the loop: external data (competitor prices from the web) flows directly into Shopify pricing decisions without human intervention.

Architecture overview

Schedule: Daily at 06:00 UTC (Trigger)
  ↓
HTTP: POST to Apify API → Run Shopify/Amazon scraper Actor
  ↓
HTTP: GET Apify Dataset Items (wait for run completion via webhook)
  ↓
Iterator: Loop through scraped competitor prices
  ↓
Shopify: Search Products (match by SKU or product title)
  ↓
Filter: competitor_price < your_price × 0.95 (competitor is 5%+ cheaper)
  ↓
Router
  ├── Branch A: Shopify → Update Product Variant Price (auto-reprice)
  └── Branch B: Slack → Post Message (alert for manual review)

Step 1: Set up the Apify scraper

1. Create a free Apify account.
2. In the Apify Store, find the Shopify Scraper actor. It extracts product titles, prices, variants, and availability from any public Shopify store.
3. Configure it with your competitors' store URLs as start URLs.
4. Test a manual run to confirm it returns the fields you need: title, price, variants[].price, handle.

Step 2: Trigger the scraper from Make

In Make, use the HTTP → Make a Request module to start the Apify Actor via the Apify API:

POST https://api.apify.com/v2/acts/apify~website-content-crawler/runs?fpr=use-apify
Authorization: Bearer YOUR_APIFY_API_TOKEN
Content-Type: application/json

{
  "startUrls": [
    { "url": "https://competitor-store.myshopify.com" }
  ],
  "maxRequestsPerCrawl": 200
}

The response includes a data.id (run ID) and data.defaultDatasetId. Save the dataset ID using Make's Set Variable module for the next step.

Step 3: Retrieve competitor prices

After the Apify run finishes (typically 2–10 minutes for a small catalog), retrieve results:

GET https://api.apify.com/v2/datasets/%7B%7BdatasetId%7D%7D/items?format=json&limit=1000&fpr=use-apify
Authorization: Bearer YOUR_APIFY_API_TOKEN

For large stores: Use Apify's webhook callback instead of polling. Configure Apify to POST to a Make webhook URL on run completion. This eliminates the need for Make to poll the API and reduces operations consumed. See the Apify + Make webhook troubleshooting guide.

Step 4: Compare and update Shopify prices

1. Iterator: Loop through each item in the Apify dataset.
2. Shopify → Search for Products: Look up the matching product by handle or title.
3. Filter: If competitor_price < {{shopify_price}} * 0.95, proceed to update.
4. Shopify → Update a Product Variant: Set the new price. A safe rule: set your price to competitor_price * 0.99 to stay 1% below the competitor.
5. Slack alert: Post a summary of all price changes made (product name, old price, new price, competitor) so your team has visibility.

For a deeper dive into the price monitoring side of this pipeline, see our automated price monitoring guide.

---

Customer Segmentation: Tag VIPs and Flag At-Risk Customers

Customer tags in Shopify power audience segmentation for email campaigns, discount eligibility, and personalized storefronts. Make automates the tagging logic that Shopify Flow can't reach across external data sources.

VIP customer tagging

Trigger: Shopify → Watch Orders (new order)

Logic:

1. After a new order, use Shopify → Get Customer to fetch the customer's full order history.
2. Add a Filter: {{customer.orders_count}} >= 5 AND {{customer.total_spent}} >= 500.
3. Shopify → Update a Customer: Add tag vip to the customer record.

Once tagged vip, your email platform (Klaviyo, Mailchimp, etc.) can segment these customers for early access, loyalty discounts, or personalized sequences automatically.

At-risk customer flagging

Trigger: Schedule (daily)

Logic:

1. Use Shopify → Search for Customers filtered to customers with orders_count >= 2.
2. Iterator: Loop through results.
3. Filter: Last order date is more than 90 days ago. Use Make's dateDifference function in the filter condition: {{dateDifference(now; customer.last_order_created_at; "days")}} > 90. This computes the number of days since the customer's last order using Make's built-in date comparison syntax.
4. Shopify → Update a Customer: Add tag at-risk.
5. Optional: Klaviyo → Add Subscriber to List to enroll them in a win-back email sequence.

This pattern works because it runs on external schedule logic — something Shopify Flow's internal event model can't replicate without custom app development.

---

Make.com Plans for Shopify Stores

Make's pricing is operation-based. One "operation" is one module execution in a scenario. The three blueprints above consume roughly:

Blueprint	Ops per run	Runs/day	Ops/month
Order Processing	~5 per order	50 orders	~7,500
Inventory Sync	~4 per check	4 checks	~480
Price Monitoring	~10 per run	1 run	~300
Customer Segmentation	~3 per customer	Daily batch of 200	~18,000

Total estimate: ~26,000 operations/month for a mid-size Shopify store. Check Make's current plans to find the right tier — the Core plan is typically sufficient for stores processing under 50 orders/day.

Get started with Make.com for free →

---

Common Shopify + Make Configuration Mistakes

1. Using polling triggers instead of webhooks Make's Shopify module defaults to polling at 15-minute intervals on lower plans. For order-critical workflows, verify your plan supports real-time webhook triggers and enable them in the module settings.

2. Not handling partial fulfillments If you fulfill orders in multiple shipments, the Watch Orders trigger fires once at order creation but not per shipment. Use Watch Fulfillments as a separate trigger for post-ship notifications.

3. Forgetting error handlers If Shopify's API is temporarily unavailable, your scenario fails silently. Add an Error Handler route after each Shopify action module — route failures to a Slack alert or an error log in Google Sheets.

4. Overwriting customer tags instead of appending The Update Customer module in Make replaces the entire tags field by default. To append a tag without removing existing ones, first fetch the customer's current tags with Get Customer, then build the new tag string conditionally: {{if(length(customer.tags) > 0; customer.tags + ", vip"; "vip")}}. This avoids malformed strings like ,,vip when existing tags are empty.

---

Frequently Asked Questions

Connect your Shopify store to Make.com via OAuth (Settings → Integrations → Shopify). Then build scenarios using Shopify trigger modules (Watch Orders, Watch Customers, Watch Inventory Levels) and action modules (Create Fulfillment, Update Product, Update Customer). No code required — every step is configured visually on Make's canvas.

Make can automate the full order lifecycle: trigger on new order creation, send confirmation emails, create fulfillments, push line items to accounting software (QuickBooks, Xero, Google Sheets), notify the warehouse via Slack, and tag customers based on order value or frequency. All steps run in parallel using Make's Router module.

Yes. Make connects to Shopify's Inventory API to read current stock levels across all locations. You can build scheduled scenarios that check inventory on a set interval, filter for products below a reorder threshold, and automatically send purchase orders to suppliers via email or API. Make can also sync inventory from external supplier spreadsheets back into Shopify.

Apify provides the web data that Make can't generate itself. Use Apify's Shopify Scraper or Amazon scrapers to extract competitor pricing, then feed that data into Make via the Apify API. Make processes the comparison logic and updates your Shopify product prices automatically — no code, no manual monitoring.

For multi-step Shopify workflows, Make.com is generally better value. Make's operations-based pricing is cheaper at scale than Zapier's per-task model, and Make's visual router handles branching logic (fulfill + notify + log simultaneously) natively. Zapier is simpler for basic 1-to-1 automations but becomes expensive for high-order-volume stores.

Shopify Flow is an internal automation tool that only connects Shopify apps on the Shopify platform. Make.com routes Shopify events to any external application — accounting software, Slack, Google Sheets, Airtable, supplier APIs, and more. For workflows that stay entirely within Shopify (loyalty points, automatic discounts, inventory transfers between locations), Flow is simpler. For cross-app workflows, Make.com is required.

---

Start Automating Your Shopify Store

The three blueprints above — order processing, inventory sync, and competitor price monitoring — cover the most time-intensive manual tasks for Shopify merchants. Together they can recover 20+ hours per week while making your store more responsive to market conditions than any manual process allows.

Create your free Make.com account and connect Shopify →

If you need web data (competitor prices, supplier catalogs, market intelligence), add Apify to the pipeline. Its pre-built Shopify, Amazon, and Google Shopping scrapers connect to Make in minutes and handle anti-bot infrastructure automatically.