Automate Shopify with n8n: Orders, Inventory & Customer Workflows

Step 1 – Create Shopify API Credentials

Before n8n can talk to Shopify, you must generate API credentials from your Shopify admin.

1. Log in to your Shopify admin panel.
2. Navigate to Apps & sales channels → Develop apps → Create an app.
3. Give the app a name (e.g., “n8n Automation”) and click Create app.
4. In the app dashboard, go to API credentials.
5. Under Admin API access token, click Generate token.
6. Select the following Access scopes (minimum required for the workflows):
   • read_orders
   • write_orders
   • read_products
   • write_products
   • read_customers
   • write_customers
   • read_draft_orders
   • write_draft_orders
7. Click Save, then copy the generated Admin API access token.
8. Also note your Shop name (the part before .myshopify.com) – you’ll need it for the API URL.

Store these two values securely. In n8nautomation.cloud you can add them as Environment Variables:

• SHOPIFY_SHOP – e.g., myawesomestore
• SHOPIFY_TOKEN – the long token you just generated

Step 2 – Set Up the n8n Workflow Foundation

We’ll start with a single workflow that contains multiple sub‑workflows (or “branches”) triggered by different Shopify events. This keeps the logic modular and easier to maintain.

1. In n8n, click Workflows → New Workflow.
2. Give it a descriptive name, e.g., Shopify Automation Suite.
3. Click the + button to add the first node.
4. Search for Shopify Trigger and add it.

Shopify Trigger Node Configuration

• Resource: Order
• Operation: Created
• Shopify Store: {{ $env["SHOPIFY_SHOP"] }}.myshopify.com
• Access Token: {{ $env["SHOPIFY_TOKEN"] }}
• Trigger On: All Orders (you can later filter by financial status if needed)

This node will fire every time a new order is placed in your store.

Branch 1 – Order Processing (Google Sheets Logging)

We’ll now add a branch that takes the order data and appends a row to a Google Sheet.

1. Click the + button on the Shopify Trigger node to create a new branch.
2. Search for Google Sheets and add the node.
3. In the Google Sheets node, set:
• Operation: Append
• Spreadsheet ID: paste the ID from your Google Sheet URL (e.g., 1BxiMVs0XRA5nFMdKvBdBZjgmUUqptlbs74OgvE2upms)
• Sheet Name: Orders (create this sheet if it doesn’t exist)
• Columns: Map the fields you want to log. Use the Expression mode to pull data from the previous node.

Field Mapping (Expression Mode)

Make sure to toggle Options → Include All Fields off and manually add each column as shown above.

Branch 2 – Inventory Alert (Slack Notification)

Instead of triggering on order creation, we’ll create a separate workflow that runs on a schedule (e.g., every 15 minutes) and checks low‑stock products.

1. Create a new workflow named Shopify Inventory Monitor.
2. Add a Cron node as the trigger.
3. Configure Cron:
• Every X: 15 minutes
• At Minute: 0 (or any minute you prefer)

Next, add a Shopify node to fetch product inventory levels.

1. After the Cron node, click + → Shopify.
2. Set:
• Resource: Product
• Operation: Get All
• Shopify Store: {{ $env["SHOPIFY_SHOP"] }}.myshopify.com
• Access Token: {{ $env["SHOPIFY_TOKEN"] }}
• Return All: true (to paginate through all products)

Now we need to filter products where inventory is below a threshold (e.g., 5). Add an IF node.

1. Connect the Shopify node to an IF node.
2. Set the condition to evaluate each product’s variants.
3. Because a product can have multiple variants, we’ll use a Function node first to flatten variant inventory.

Function Node – Flatten Variants

// Input: array of products from Shopify node
const output = [];

for (const product of items[0].json) {
  for (const variant of product.variants) {
    // Assume inventory quantity is stored in variant.inventory_quantity
    const qty = variant.inventory_quantity ?? 0;
    output.push({
      productId: product.id,
      productTitle: product.title,
      variantId: variant.id,
      variantTitle: variant.title,
      inventoryQuantity: qty,
      sku: variant.sku ?? ''
    });
  }
}
return output;

Set the Function node to Execute Once Per Item (default) and connect its output to the IF node.

IF Node Condition

• Value 1: {{ $json["inventoryQuantity"] }}
• Operation: < (less than)
• Value 2: 5 (adjust threshold as needed)

Connect the True output of the IF node to a Slack node.

1. Add a Slack node, choose Operation: Send Message.
2. Authentication: Create a Slack credential of type Incoming Webhook (or use OAuth if you prefer).
3. Set:
• Channel: #inventory-alerts (or your preferred channel)
• Text (use Expression mode):

{{ 
  `:warning: Low stock alert!\n*Product:* {{$json["productTitle"]}}\n*Variant:* {{$json["variantTitle"]}}\n*SKU:* {{$json["sku"] || "N/A"}}\n*Current Qty:* {{$json["inventoryQuantity"]}}\n*Threshold:* 5
`}}

Optionally, add an Email node after the Slack node to send a duplicate alert to a distribution list.

Branch 3 – Abandoned Cart Follow‑Up

Shopify does not expose a native “abandoned cart” webhook, but we can poll for carts that have been updated more than X minutes ago and have no associated order.

1. Create a new workflow named Shopify Abandoned Cart.
2. Add a Cron trigger (run every 20 minutes).
3. Add a Shopify node to fetch checkouts (carts).
• Resource: Checkout
• Operation: Get All
• Shopify Store: {{ $env["SHOPIFY_SHOP"] }}.myshopify.com
• Access Token: {{ $env["SHOPIFY_TOKEN"] }}
• Return All: true

Next, filter checkouts that have not been completed and were last updated more than, say, 30 minutes ago.

1. Add a Function node to compute the age of each checkout.

// Input: array of checkouts
const now = new Date();
const output = [];

for (const c of items[0].json) {
  // Skip if checkout already has an order (completed)
  if (c.order_id) continue;

  const updatedAt = new Date(c.updated_at);
  const diffMs = now - updatedAt;
  const diffMinutes = diffMs / (1000 * 60);

  if (diffMinutes > 30) { // threshold
    output.push({
      checkoutId: c.id,
      email: c.email,
      cartToken: c.cart_token,
      updatedAt: c.updated_at,
      minutesAgo: Math.round(diffMinutes),
      lineItems: c.line_items
    });
  }
}
return output;

Connect the Function node to an IF node that simply checks if the array length > 0 (you can also skip the IF and go straight to the email node; the email node will handle an empty array gracefully).

Add an Email node (or SendGrid, SMTP, etc.) to send a follow‑up message.

1. Configure the Email node:
• From: your verified sender address (e.g., orders@yourstore.com)
• To: {{ $json["email"] }}
• Subject: We noticed you left something behind!
• Text (HTML mode recommended):

<p>Hi {{ $json["email"].split("@")[0] }},</p>
<p>It looks like you forgot to complete your purchase. Here’s what you left in your cart:</p>
<ul>
{{#each $json["lineItems"]}}
  <li>{{this.quantity}} × {{this.title}} ({{this.variant_title}}) – ${{this.price}}</li>
{{/each}}
</ul>
<p>Complete your order now and enjoy free shipping:</p>
<p><a href="https://{{$env["SHOPIFY_SHOP"]}}.myshopify.com/cart/{{$json["cartToken"]}}?checkout_url=%2Fcheckout%2F{{$json["cartToken"]}}">Return to Cart</a></p>
<p>Best,</p>
<p>The {{ $env["SHOPIFY_SHOP"] }} Team</p>

Tip: If you want a series of reminders (e.g., 1 hour, 4 hours, 24 hours), duplicate the workflow and adjust the Cron schedule and the time threshold in the Function node.

Branch 4 – Customer Tagging Based on Order Value

Finally, we’ll automatically tag customers when they place a high‑value order (e.g., > $200) or when they reach a lifetime spend threshold.

1. Create a workflow named Shopify Customer Tagger.
2. Use the same Shopify Trigger node as in Step 2 (Order → Created).
3. Add a Function node to calculate whether the order qualifies for a tag.

// Input: order object from Shopify Trigger
const order = items[0].json;
const total = parseFloat(order.total_price) || 0;
const customerId = order.customer?.id;

// Define your tagging rules
let tagsToAdd = [];

if (total > 200) {
  tagsToAdd.push("high-value");
}

// Example: fetch lifetime spend from a custom meta field or external DB.
// For simplicity, we’ll just tag based on this order only.
// In a real scenario you could query the customer resource and sum past orders.

return {
  customerId,
  tagsToAdd,
  orderId: order.id
};

Connect the Function node to a Shopify node (resource: Customer, operation: Update).

1. Set the Shopify node:
• Resource: Customer
• Operation: Update
• Customer ID: {{ $json["customerId"] }}
• Fields to Update: tags (we’ll append)

To append tags without overwriting existing ones, we need to fetch the current tags first, merge, then update.

1. Insert another Shopify node before the Update node:
• Resource: Customer
• Operation: Get
• Customer ID: {{ $json["customerId"] }}

Add a Function node to merge tags:

// Input 0: current customer (from Get node)
// Input 1: tagsToAdd + identifiers (from previous Function node)
const customer = items[0].json;
const newTags = items[1].json.tagsToAdd || [];

const currentTags = (customer.tags || "").split(",").map(t => t.trim()).filter(t => t);
const merged = [...new Set([...currentTags, ...newTags])]; // deduplicateconst tagsString = merged.join(", ");

return {
  customerId: items[1].json.customerId,
  tags: tagsString,
  orderId: items[1].json.orderId};

Finally, connect this Function node to the Shopify Update node, mapping the tags field to {{ $json["tags"] }}.

Testing the Workflows

Before activating any workflow, run a test execution to ensure data flows correctly.

1. In each workflow, click the Execute Workflow button (top‑right).
2. For trigger‑based workflows (Order Created, Abandoned Cart), you can manually fire a test event:
• Place a test order in Shopify (use a discount code to make it $0 if you don’t want to charge).
• Create a test checkout and leave it idle for >30 minutes to trigger the abandoned cart branch.
• Adjust a product’s inventory to below the threshold to see the Slack alert.
3. Check the output of each node:
• Google Sheets node should have added a new row with the expected values.
• Slack node should have posted a message in the designated channel.
• Email node should have delivered the abandoned‑cart reminder (check spam folder).
• Shopify Update node should have added the appropriate tag to the customer profile (view the customer in Shopify admin).
4. If any node fails, examine the error message in the node’s output panel; n8n shows the exact HTTP response from Shopify, which often includes helpful details (e.g., missing permissions).

Once satisfied, toggle the workflow’s Active switch to enable automatic execution.

Common Issues & Troubleshooting

1. “Invalid Shopify domain” or “401 Unauthorized”

This usually means the SHOPIFY_SHOP or SHOPIFY_TOKEN environment variables are missing, malformed, or the token lacks required scopes.

• Double‑check that the shop name does not include https:// or .myshopify.com – just the subdomain.
• Verify the token was generated with read_orders, write_orders, read_products, write_products, read_customers, write_customers scopes.
• If you recently rotated the token, update the environment variable and restart the workflow (or redeploy).

2. Google Sheets “Access Not Configured”

n8n’s Google Sheets node uses OAuth2. If you see an error about missing access:

• In n8n, go to Credentials → New Credential → Google Sheets OAuth2.
• Follow the prompts to authorize n8n to access your Google Drive.
• Ensure the target spreadsheet is shared with the email address used in the OAuth flow (or set sharing to “Anyone with the link can edit”).

3. Slack webhook returns “invalid_payload”

The Slack node expects a plain text payload unless you enable “Attachments” or “Blocks”. If you’re using markdown‑style formatting, switch the node to Block Kit mode or escape characters.

• Alternatively, keep the message plain text and use Slack’s native formatting (*bold*, _italic_).

4. Abandoned cart workflow fires too often or not at all

Because we poll checkouts, timing is crucial.

• If you see many duplicate emails, increase the Cron interval (e.g., to 30 minutes) or raise the minutes‑ago threshold.
• If you see no emails, verify that test checkouts are truly order_id: null and that the updated_at field is being set correctly (Shopify updates it when cart items change).
• Consider adding a filter to exclude checkouts with an email address that matches a known internal address (to avoid spamming yourself).

5. Customer tagging creates duplicate tags

If you notice the same tag appearing multiple times, the merging function may not be deduplicating correctly.

• Ensure you trim whitespace and convert to a consistent case before deduplication.
• In the Function node, replace the merge line with:

const normalized = currentTags.map(t => t.toLowerCase().trim());
const normalizedNew = newTags.map(t => t.toLowerCase().trim());
const mergedSet = new Set([...normalized, ...normalizedNew]);
const merged = Array.from(mergedSet).map(t => t.charAt(0).toUpperCase() + t.slice(1)); // optional title casereturn { tagsString: merged.join(", ") };

6. Workflow exceeds execution time limit

Large stores with thousands of products can cause the Inventory Monitor workflow to timeout.

• Enable pagination in the Shopify node (Return All = false) and use the Shopify Node’s “Page Size” to fetch 50‑100 records per call, then loop using the IF node to continue until hasNextPage is false.
• Alternatively, move the inventory check to a separate serverless function (e.g., AWS Lambda) and call it via n8n’s HTTP Request node.

Conclusion

By leveraging n8n’s flexible node‑based architecture, you can turn repetitive Shopify chores into reliable, event‑driven automations. The four workflows demonstrated here—order logging, low‑stock alerts, abandoned cart recovery, and dynamic customer tagging—form a solid foundation that you can expand:

• Add a Delay node after the abandoned cart email to schedule a second reminder.
• Use the HTTP Request node to push order data into a data warehouse (e.g., Snowflake, BigQuery) for deeper analytics.
• Integrate with SMS providers like Twilio for time‑sensitive alerts.
• Create a customer‑segmentation workflow that tags users based on browsing behavior (using Shopify’s Visit webhook or Google Analytics events).

Remember that security and maintainability are key: store secrets in environment variables, document each workflow’s purpose, and periodically review credentials and permissions.

If you prefer a managed experience that handles updates, backups, and SSL automatically, consider hosting your n8n instance on n8nautomation.cloud. Their platform lets you focus on building automations rather than managing infrastructure, ensuring your Shopify workflows stay online and performant 24/7.

Happy automating!