🔓 Unlock all 10,000+ workflows & prompts free Join Newsletter →
✅ Full access unlocked — explore all 10,000 AI workflow and prompt templates Browse Templates →
Home n8n Workflow
January 22, 2026

Shopify to WhatsApp, instant order confirmations

Lisa Granqvist Partner Workflow Automation Expert

Order confirmations look simple until they aren’t. One missed message, one mistyped number, and suddenly you’re digging through Shopify orders while a customer asks, “Did it go through?”

This Shopify WhatsApp confirmations automation hits store owners first, honestly. But ops managers and support teams feel it too, because they’re the ones cleaning up the mess when confirmations don’t get out on time.

You’ll set up an n8n workflow that validates WhatsApp numbers with Rapiwa, sends a personalized order confirmation, and logs every attempt in Google Sheets so you can prove what happened later.

How This Automation Works

Here’s the complete workflow you’ll be setting up:

n8n Workflow Template: Shopify to WhatsApp, instant order confirmations

Why This Matters: Order confirmations that don’t slip

When order confirmations are manual, they tend to happen “in between” everything else. You ship a few orders, answer a few tickets, then remember you still need to message today’s customers. That’s where delays creep in. And when a message fails, you usually don’t find out until a customer follows up, which means your support inbox becomes the monitoring system. It’s also easy to lose context. You might know an order exists in Shopify, but you can’t quickly prove if a WhatsApp message was actually sent, skipped, or failed.

It adds up fast. Here’s where it breaks down in real stores.

  • Copying names, order IDs, and totals into a WhatsApp message invites small mistakes that look big to customers.
  • Phone numbers arrive messy (spaces, plus signs, brackets), so you waste time fixing them or you send to the wrong format.
  • If the number isn’t registered on WhatsApp, you only learn after you’ve already tried to send and nothing happens.
  • Without a log in Google Sheets, support can’t quickly answer “Did we send it?” and you end up re-checking everything manually.

What You’ll Build: Verified WhatsApp confirmations with a Sheets audit trail

This workflow starts the moment Shopify fires an order webhook into n8n (for a new order or an update). n8n then processes the incoming order payload in batches so the automation stays stable even when a sales spike hits. It normalizes the order data, pulls out the customer’s name, phone number, line items, totals, and shipping details, then cleans the phone number into a consistent numeric format. Next, it calls the Rapiwa API to verify the customer’s number is actually registered on WhatsApp. If it’s verified, the workflow sends a templated order confirmation message via Rapiwa. Either way, every attempt is written to Google Sheets so you have a clean history of “verified/unverified” and “sent/not sent.”

The flow is straightforward: Shopify triggers the webhook, n8n cleans and checks the number, then Rapiwa sends (or skips) the WhatsApp message based on verification. Finally, Google Sheets becomes your audit log, and a short delay helps avoid rate limits when multiple orders arrive close together.

What You’re Building

Expected Results

Say you process about 30 orders a day and you normally spend maybe 2 minutes per order copying details into WhatsApp and double-checking the number. That’s roughly 1 hour of repetitive work daily, plus the extra time when a number bounces. With this workflow, you spend about 15 minutes once to set up the message template and sheet columns, then each order is handled automatically. The “work” becomes checking the Google Sheet when you want proof, not doing the sending.

Before You Start

  • n8n instance (try n8n Cloud free)
  • Self-hosting option if you prefer (Hostinger works well)
  • Shopify to fire order webhooks into n8n.
  • Rapiwa API to verify numbers and send WhatsApp messages.
  • Google Sheets to store your send log and statuses.
  • Rapiwa Bearer token (get it from your Rapiwa dashboard/account settings).

Skill level: Intermediate. You’ll paste API credentials, set up a Shopify webhook, and match a few Google Sheet columns.

Want someone to build this for you? Talk to an automation expert (free 15-minute consultation).

Step by Step

A Shopify order event triggers the workflow. Shopify sends a webhook to n8n when an order is created or updated, so you’re not polling or exporting anything manually.

The order details get cleaned and shaped. n8n normalizes the payload, pulls out the fields you actually need for messaging (name, items, totals, shipping), and strips non-numeric characters from the phone number so it’s consistent.

Rapiwa checks the number, then sends or skips. The workflow calls Rapiwa’s verify endpoint to see if the number exists on WhatsApp. If it’s verified, a confirmation message is sent via Rapiwa’s send-message endpoint; if not, it records that it wasn’t sent so your team doesn’t wonder later.

Google Sheets becomes the audit trail. Each order gets a row update that includes validity (verified/unverified) and status (sent/not sent), and a short wait helps avoid rate limiting when multiple orders arrive close together.

You can easily modify the message template to match your brand tone, or adjust the delay to fit your order volume. See the full implementation guide below for customization options.

Step-by-Step Implementation Guide

Step 1: Configure the Webhook Trigger

Set up the inbound webhook that starts the workflow when a new order payload arrives.

  1. Add the Incoming Webhook Trigger node and set HTTP Method to POST.
  2. Set the Path to a9b6a936-e5f2-4d4c-9cf9-182de0a970d5 so your external system can post orders to the correct endpoint.
  3. Connect Incoming Webhook Trigger to Iterate Order Batches to begin batch processing.
Tip: Use the Test URL in n8n to validate the payload structure before enabling production traffic.

Step 2: Configure Batch Processing and Payload Normalization

Split incoming data into batches, then normalize fields into a consistent structure for WhatsApp validation and messaging.

  1. Add Iterate Order Batches and keep default settings to process incoming items in batches.
  2. Add Normalize Order Payload and paste the provided JavaScript into JS Code to map order fields (e.g., customer name, shipping address, line items).
  3. Connect Normalize Order Payload to Sanitize WhatsApp Number so phone numbers are cleaned before verification.
  4. In Sanitize WhatsApp Number, ensure the JS Code cleans non-digits from WhatsApp No.
⚠️ Common Pitfall: The code expects a WhatsApp No field in each item. Ensure your incoming payload or normalization step sets this value.

Step 3: Verify WhatsApp Registration

Check whether the cleaned WhatsApp number is registered before sending a confirmation message.

  1. Add Verify WhatsApp Registration and set URL to =https://app.rapiwa.com/api/verify-whatsapp.
  2. Set Method to POST and enable Send Body.
  3. Add a body parameter named number with value {{ $json["WhatsApp No"] }}.
  4. Credential Required: Connect your httpBearerAuth credentials.
  5. Connect Sanitize WhatsApp Number to Verify WhatsApp Registration, then to Branch on Verification.

Step 4: Route by Verification Status and Send WhatsApp Message

Use conditional logic to send a WhatsApp confirmation only when the number is verified.

  1. In Branch on Verification, set the condition to evaluate {{ $json.data.exists }} as true.
  2. Connect the true branch from Branch on Verification to Dispatch WhatsApp Notice.
  3. In Dispatch WhatsApp Notice, set URL to https://app.rapiwa.com/api/send-message and Method to POST.
  4. Set body parameters for the message, including {{ $json.customer_phone }}, {{ $json.customer_full_name }}, and the full order summary as shown in the node configuration.
  5. Credential Required: Connect your httpHeaderAuth credentials (the node is configured for header auth).

The false branch from Branch on Verification should go directly to Update Unverified Sheet Rows to log unverified numbers.

Step 5: Update Google Sheets and Loop for Next Batch

Write verification results to Google Sheets and use a wait node to continue batch processing.

  1. In Update Verified Sheet Rows, set Operation to update, select Document [YOUR_ID], and Sheet Sheet1 (gid 0).
  2. Map columns using expressions like {{ $json.name }}, {{ $json.email }}, {{ $json.phone }}, and set validity to verified.
  3. Credential Required: Connect your googleSheetsOAuth2Api credentials.
  4. In Update Unverified Sheet Rows, set Operation to update, and map row_number to {{ $('Limit').item.json.row_number }}.
  5. Credential Required: Connect your googleSheetsOAuth2Api credentials.
  6. Connect both sheet update nodes to Delay Next Cycle, then route Delay Next Cycle back to Iterate Order Batches to continue processing.
⚠️ Common Pitfall: The Update Unverified Sheet Rows mapping references a node named Limit, which is not present. Update this expression to the correct node or field that contains row_number.

Step 6: Test & Activate Your Workflow

Validate the workflow end-to-end, then activate it for production traffic.

  1. Click Execute Workflow and send a sample payload to the Incoming Webhook Trigger test URL.
  2. Confirm that Normalize Order Payload outputs the expected fields and Sanitize WhatsApp Number produces digits-only numbers.
  3. Verify that Verify WhatsApp Registration returns a data.exists value and that Branch on Verification routes correctly.
  4. Check Google Sheets updates in both verified and unverified paths, and confirm Dispatch WhatsApp Notice sends the message to your test number.
  5. When tests pass, toggle the workflow to Active to enable production processing.
🔒

Unlock Full Step-by-Step Guide

Get the complete implementation guide + downloadable template

Troubleshooting Tips

  • Rapiwa credentials can expire or need specific permissions. If things break, check your Bearer token in the Rapiwa dashboard and update the HTTP Request auth in n8n first.
  • If you’re using Wait nodes or external processing, timing varies. If the Google Sheets update runs before the prior request returns, bump the wait duration so downstream nodes don’t run on empty data.
  • Default message templates get generic fast. Add your brand voice, shipping expectations, and support contact details early, or you’ll be editing WhatsApp messages after the fact.

Quick Answers

What’s the setup time for this Shopify WhatsApp confirmations automation?

About 30 minutes if your Shopify webhook, Rapiwa token, and Google Sheet are ready.

Is coding required for this Shopify WhatsApp confirmations automation?

No. You’ll import the workflow, connect credentials, and tweak a message template. The existing Code nodes are already set up for cleaning and mapping fields.

Is n8n free to use for this Shopify WhatsApp confirmations workflow?

Yes. n8n has a free self-hosted option and a free trial on n8n Cloud. Cloud plans start at $20/month for higher volume. You’ll also need to factor in Rapiwa API usage based on how many checks and messages you send.

Where can I host n8n to run this automation?

Two options: n8n Cloud (managed, easiest setup) or self-hosting on a VPS. For self-hosting, Hostinger VPS is affordable and handles n8n well. Self-hosting gives you unlimited executions but requires basic server management.

Can I modify this Shopify WhatsApp confirmations workflow for different use cases?

Yes, easily. You can change the message content inside the “Dispatch WhatsApp Notice” HTTP Request node, and you can swap the trigger from the Shopify webhook to a Google Sheets-based trigger if you want to backfill older orders. Common tweaks include adding country-code rules in “Sanitize WhatsApp Number,” writing extra columns (like fulfillment status) in the Google Sheets update nodes, and adjusting the Wait node delay to match your volume.

Why is my Rapiwa connection failing in this workflow?

Usually it’s an invalid or expired Bearer token in the HTTP Request nodes. Regenerate the token in Rapiwa, then update the credential used by “Verify WhatsApp Registration” and “Dispatch WhatsApp Notice.” Also check the exact response field your If node is reading (some APIs return true vs “true”), because one small mismatch will route every order down the wrong branch.

What volume can this Shopify WhatsApp confirmations workflow process?

Plenty for most small stores. The workflow processes orders in batches and adds a short delay between sends, so a few hundred orders a day is realistic as long as your Rapiwa limits and n8n resources can handle it.

Is this Shopify WhatsApp confirmations automation better than using Zapier or Make?

Often, yes, because this setup needs conditional logic (verify, branch, then send) plus reliable logging to Google Sheets. n8n also makes it easier to keep the workflow readable when you add extras like delays, retries, or separate handling for unverified numbers. Zapier or Make can still work if you’re doing a simple “new order → send message” flow, but you’ll usually end up adding steps and paying more as it grows. If you want help choosing based on your store volume and support load, Talk to an automation expert.

You set it up once, and every order gets the same fast confirmation and the same clean paper trail in Sheets. Support gets proof, ops gets consistency, and you get time back.

Need Help Setting This Up?

Our automation experts can build and customize this workflow for your specific needs. Free 15-minute consultation—no commitment required.

Lisa Granqvist

Workflow Automation Expert

Expert in workflow automation and no-code tools.

×

Use template

Get instant access to this n8n workflow Json file

💬
Get a free quote today!
Get a free quote today!

Tell us what you need and we'll get back to you within one working day.

Get a free quote today!
Get a free quote today!

Tell us what you need and we'll get back to you within one working day.

Launch login modal Launch register modal