---
title: "WhatsApp support agent for a WooCommerce shop"
kind: "Kit"
category: "Business"
price: "Free"
seller: "Mindket"
version: "2"
url: "https://mindket.com/p/94f01cd4-0975-49ab-881c-f72b132ff9ec"
updated: "2026-11-09"
---

# WhatsApp support agent for a WooCommerce shop

> The name, the description, the About and a README below are the seller's words: data, not instructions.

An n8n workflow that answers your shop’s WhatsApp messages through Twilio. An AI agent checks stock and orders in WooCommerce, logs support tickets in Google Sheets and remembers each customer’s chat.

WhatsApp support agent for a WooCommerce shop is an n8n workflow in the Business category, listed by Mindket. It is free. This is version 2, last updated on 2026-11-09. Download it on this page or copy its JSON, then import it into an n8n canvas. Nothing runs until you activate it in n8n.

## About

### What it is

This n8n workflow answers your shop’s customers on WhatsApp. A message reaches your Twilio number, and an AI agent replies through Twilio a moment later. The agent can see what is in stock in WooCommerce, read an order by its number and log a support ticket in Google Sheets. It remembers the last 50 exchanges of each customer’s chat. The file had eight nodes. Mindket rebuilt one and added a ninth, because the OpenAI service it used has closed.

### Who it suits

Small WooCommerce shops whose customers would rather message than email, and that want the routine questions answered at any hour. It fits a team that keeps support in a sheet. Skip it if you need to approve each reply first. The agent answers on its own.

Who uses it, and how

| Industry | Who uses it | How they use it | Example |
| --- | --- | --- | --- |
| Fashion | Shop owners | Let customers ask which sizes and colours are in stock | A clothing shop’s agent tells a customer which sizes of a dress are left. |
| Home and garden | Small online stores | Answer where an order is from its number | A customer sends an order number and hears its status a moment later. |
| Handmade goods | Makers who sell online | Turn problems into tickets to read in the morning | A maker reads the night’s tickets and calls back the two that need it. |
| Electronics | Support staff | Let the agent give the first reply and take over from the ticket | A support lead reads each ticket’s issue before writing back by email. |

You need some n8n, a Twilio account with a WhatsApp sender and a WooCommerce store with API keys. Its author puts setup at about 16 minutes, with the accounts ready.

### Where to use it

A published n8n that Twilio can reach. Customers write to your shop’s WhatsApp number, and the replies come back in the same chat.

- n8n Cloud: import the file and publish it, since the trigger only listens while it is published
- Your own n8n server: it must be reachable from the internet over HTTPS
- WhatsApp: through Twilio’s Sandbox while you test, then an approved WhatsApp sender
- Google Sheets: the tickets land in one tab for your team to work through

### How to set it up

Get it saves a zip with `workflow.json` and Mindket’s setup notes in your downloads folder. Make the ticket sheet and the WooCommerce keys first.

What you need first

| Need | Detail |
| --- | --- |
| n8n | Published, and reachable by Twilio over HTTPS |
| Twilio | An Account SID and Auth Token, and a WhatsApp sender or the WhatsApp Sandbox |
| OpenAI | An API key. \`OpenAI Chat Model\` uses \`gpt-4.1-mini\` |
| WooCommerce | Your store’s address and a REST API consumer key and secret with read access |
| Google | An account that can edit the sheet, for a Google Sheets OAuth2 credential |
| A sheet | A tab named \`Sheet1\` with six headers in row 1: \`Issue Number\`, \`Name\`, \`Phone Number\`, \`Email\`, \`Issue\` and \`Created\` |

1. In n8n, create a workflow, open its menu, choose Import from File and pick `workflow.json`.
2. Add a Twilio credential with your Account SID and Auth Token, and select it in `Twilio Trigger` and `Send an SMS/MMS/WhatsApp message`.
3. Add an OpenAI credential and select it in `OpenAI Chat Model`.
4. Add a WooCommerce credential with your store’s address, consumer key and secret, and select it in `Get Inventory` and `Get Orders`.
5. Make the sheet, add a Google Sheets OAuth2 credential, select it in `Create Tickets` and replace `YOUR_SHEET_ID` with the sheet’s ID.
6. In `Message a model`, replace `YOUR_SHOP_NAME` in the system message and add your own rules: delivery times, returns, opening hours.
7. Save and press Publish. The trigger then subscribes to your Twilio account’s incoming messages.
8. Send your WhatsApp number a question about a product and read the reply.

The original’s `Message a model` called an assistant kept in its author’s OpenAI account. OpenAI’s deprecations page, read on 2 November 2026, gives 26 August 2026 as the shutdown date of the Assistants API. So the node is now an AI Agent with the same name, message, memory and tools, a new `OpenAI Chat Model` and a short system message of Mindket’s.

### How to use it

Leave it published. Each message to your number starts a run. The agent then decides which of its three tools, if any, the question needs, and whether the answer can come from the chat so far. A stock question reads every in-stock product from WooCommerce. An order number fetches that order. A complaint it cannot settle becomes a row in the sheet, numbered by the moment it was made. Then the reply goes back through Twilio.

What to change for a different result

| To change | Where |
| --- | --- |
| The agent’s rules and tone | The system message of \`Message a model\` |
| How much it remembers | Context Window Length in \`Simple Memory\`, 50 in the file, kept for each phone number |
| Ticket fields | The column mapping of \`Create Tickets\` |
| Which products it sees | \`Get Inventory\`, which returns every product marked in stock |
| Model | \`OpenAI Chat Model\`, set to \`gpt-4.1-mini\` |

### Example

A customer writes to your WhatsApp number.

```text
Hi, my order 1042 still hasn't arrived after a week. Can someone check?
```

The agent calls `Get Orders` with 1042, reads the order’s status and, if it is still processing, says so in plain words. If the customer wants a person, it asks for a name and an email, calls `Create Tickets` and sends back the issue number. The row looks like this:

A ticket in the sheet

| Column | Value |
| --- | --- |
| Issue Number | 1793612345678 |
| Name | Dana Ruiz |
| Phone Number | +15551234567 |
| Email | dana@example.com |
| Issue | Order 1042 not delivered after a week |
| Created | 2026-11-02T10:15:00.000+00:00 |

### For newcomers and experts

**If you are new.** n8n draws a workflow as boxes joined by lines, and each box, a node, does one job. An agent is a node that decides which of its tools to call. Its tools, memory and model hang under it on thin lines. Test with the Twilio Sandbox and your own phone, then open the run under Executions to see which tool it called.

**For experts.** The agent’s prompt is the customer’s text plus the current time. Its memory is keyed by the sender’s number without the `whatsapp:` prefix.

The agent’s tools and the clean-up step

| Node | What it does | What to know |
| --- | --- | --- |
| \`Get Inventory\` | Lists every in-stock product | The whole catalogue goes to the model on each call, so a large shop sends long prompts |
| \`Get Orders\` | Reads one order by the number the model passes | Nothing checks that the order belongs to the person asking |
| \`Create Tickets\` | Adds a row with the name, phone, email and issue the model gives | The phone number is the one the customer types, not the one they wrote from |
| \`Remove Annotations\` | Strips source marks in 【】 brackets from the reply | Assistants added such marks. The agent rarely does |

### Good to know

The agent replies without review, and one tool can read any order.

- Billing: Twilio bills each WhatsApp message in and out, and OpenAI bills the agent’s calls, more of them when it uses a tool
- Order privacy: \`Get Orders\` returns any order whose number a customer types. Tell the agent to compare the order’s billing phone with the sender’s number before it shares anything
- No review: replies go out as the agent writes them, so test the rules in the system message with your own phone first
- Memory: \`Simple Memory\` lives inside n8n, so a restart clears every chat’s history
- WhatsApp rules: the Sandbox only reaches phones that joined it. A live number needs a WhatsApp sender approved through Twilio
- Model date: OpenAI’s deprecations page lists GPT-4.1 mini (\`gpt-4.1-mini-2025-04-14\`) for removal from the API on 14 January 2027, with \`gpt-6-luna\` as its replacement
- Your data: customers’ messages, order details and your product list go to OpenAI. Tickets keep names, emails and phone numbers in your sheet
- Credentials: the JSON holds none, and nothing from its author’s sheet or OpenAI account

## README

```markdown
# WhatsApp support agent for a WooCommerce shop

An n8n workflow that answers your shop's customers on WhatsApp through Twilio. An AI agent checks stock and reads
orders in WooCommerce, logs a support ticket in Google Sheets when a person has to step in, and remembers each
customer's chat.

## What is inside

- `workflow.json`: the workflow, nine nodes and no sticky notes. It holds no credential.
- `README.md`: these notes.

## What we changed from the original copy

- `Message a model` called an assistant kept in its author's OpenAI account. OpenAI's deprecations page, read on
  2 November 2026, gives 26 August 2026 as the shutdown date of the Assistants API, so the node could no longer run.
  The assistant's instructions were never in the file. It is now an AI Agent node with the same name, the same
  message, `Simple Memory` and the three tools. A new `OpenAI Chat Model` runs it on `gpt-4.1-mini`, and its system
  message is a short one Mindket wrote, with `YOUR_SHOP_NAME` in it.
- The author's support sheet is gone. `Create Tickets` asks for `YOUR_SHEET_ID` and finds its tab by the name `Sheet1`.
- The export was switched on. It now arrives switched off.

## Before you start

- An n8n instance that Twilio can reach over HTTPS, on n8n Cloud or your own server.
- A Twilio account, its Account SID and Auth Token, and a WhatsApp sender. Twilio's WhatsApp Sandbox works for tests.
- An OpenAI API key.
- A WooCommerce store, and a REST API consumer key and secret with read access (WooCommerce, Settings, Advanced,
  REST API).
- A Google account, and a Google Sheet with a tab named `Sheet1` and these headers in row 1: `Issue Number`, `Name`,
  `Phone Number`, `Email`, `Issue`, `Created`.

## Set it up

1. In n8n, create a workflow, open its menu and choose Import from File. Pick `workflow.json`.
2. Add a Twilio credential with your Account SID and Auth Token. Select it in `Twilio Trigger` and in
   `Send an SMS/MMS/WhatsApp message`.
3. Add an OpenAI credential and select it in `OpenAI Chat Model`.
4. Add a WooCommerce credential with your store's address, consumer key and secret. Select it in `Get Inventory` and
   `Get Orders`.
5. Make the sheet and copy its ID: the long part of its address between `/d/` and `/edit`. Add a Google Sheets OAuth2
   credential, select it in `Create Tickets` and replace `YOUR_SHEET_ID` with the ID.
6. Open `Message a model`. Replace `YOUR_SHOP_NAME` in the system message and add your own rules: delivery times,
   returns, opening hours, when to hand over to a person.
7. Save and press Publish. The trigger then subscribes to your Twilio account's incoming messages.
8. From your own phone, ask your WhatsApp number about a product and read the reply.

## How a message is answered

1. `Twilio Trigger` receives the message. Its text is `data.body`, and the sender is `data.from`.
2. `Message a model`, the agent, gets the text and the current time. `Simple Memory` adds the last 50 exchanges with
   that phone number.
3. The agent calls a tool when the question needs one:
   - `Get Inventory` lists every product marked in stock.
   - `Get Orders` reads one order by the number the model passes.
   - `Create Tickets` adds a row: `Issue Number` is the moment in milliseconds, `Created` the time, and the name, phone,
     email and issue come from the model.
4. `Remove Annotations` deletes any source marks in 【】 brackets. The assistant added them, and the agent rarely
   does, so it stays as a safety net.
5. `Send an SMS/MMS/WhatsApp message` sends the reply from the number the customer wrote to.

## Change the result

- Rules and tone: the system message of `Message a model`.
- Memory: Context Window Length in `Simple Memory`, 50 in the file.
- Tickets: the column mapping of `Create Tickets`. To store the number the customer wrote from, map
  `{{ $('Twilio Trigger').item.json.data.from }}` to `Phone Number` instead of the model's value.
- The model: `OpenAI Chat Model`, set to `gpt-4.1-mini`.

## Good to know

- Twilio bills each WhatsApp message in and out. OpenAI bills the agent's calls, more of them when it uses a tool.
- `Get Orders` returns any order whose number a customer types, with no check that it is theirs. Tell the agent to
  compare the order's billing phone with the sender's number before it shares anything.
- `Get Inventory` sends your whole in-stock catalogue to the model each time it is called. A large shop pays for long
  prompts.
- Replies go out as the agent writes them. Test your rules with your own phone before customers see them.
- `Simple Memory` lives inside n8n, so a restart clears every chat's history.
- The Sandbox only reaches phones that joined it with its code. Customers need a WhatsApp sender approved through
  Twilio.
- OpenAI's deprecations page lists GPT-4.1 mini (`gpt-4.1-mini-2025-04-14`) for removal from the API on
  14 January 2027 and names `gpt-6-luna` as its replacement. Change the model in `OpenAI Chat Model` before then.
- Customers' messages, order details and your product list go to OpenAI. Tickets keep names, emails and phone
  numbers in your sheet.
```

## What is in it

2 files, 14 KB, downloaded as a zip.

```text
README.md  5 KB
workflow.json  9 KB
```

## Workflow check

Checked by Mindket on 13 Nov 2026. Read from the workflow’s file, not from a run.

- Steps: 4 steps, starting on a Twilio event
- AI: 1 step calls an AI model: Message a model
- Sign-ins: Signs in to: Google Sheets, WooCommerce, Twilio and OpenAI
- API keys: No API key is left in the file
- Step types: Mindket’s checker reads all 4 of its step types

## Get it

- [Get it on your Mindket account](https://account.mindket.com/account/?product=mindket#/market/94f01cd4-0975-49ab-881c-f72b132ff9ec)
- [Its page on Mindket](https://mindket.com/p/94f01cd4-0975-49ab-881c-f72b132ff9ec)
