Gorgias Macros Explained (2026): Templates, Variables & Automation

This guide explains what Gorgias Macros actually are, how to create and organize them, how variables pull live order data from Shopify, which actions a macro can bundle, how macros fit into Rules and the AI Agent, the keyboard shortcuts that make them fast, and the pitfalls that quietly bite teams. It's verified against Gorgias's own Helpdesk Documentation as of June 2026 — though Gorgias revises its UI and naming periodically, so confirm the exact labels in your own account. New to the platform? Start with what is Gorgias for the bigger picture. (And to be clear: this is Gorgias the ecommerce help desk, not the ancient Greek dialogue of the same name.)

What is a Gorgias Macro?

A macro in Gorgias is a reusable, pre-written response — what other help desks call a canned response, saved reply, or template. You'll sometimes see "Gorgias templates" or "Gorgias canned responses" used interchangeably; in Gorgias's own product they're called Macros.

But a macro is more than boilerplate text. The thing that makes Gorgias macros powerful is that each one can bundle three layers together:

• A response — the message text, written once and reused, with variables for personalization.
• Tags — labels applied to the ticket when the macro runs (handy for reporting and routing).
• Actions — operations on the ticket and your connected store, like changing status, assigning an agent, or refunding a Shopify order.

So instead of "paste reply, then manually tag, then close the ticket, then issue the refund," an agent applies one macro and all four happen at once. Gorgias describes this as letting agents "respond to customers and take actions on tickets in a single click" (Gorgias docs).

How to create a macro in Gorgias (step by step)

Setting up your first macro takes a couple of minutes. Based on the current Gorgias documentation, the path is:

1. Open the workflow tools. From your helpdesk, click the dropdown menu in the top-left corner and select Workflows.
2. Find Macros. Locate Tools, then select Macros.
3. Start a new macro. Click Create macro in the top right.
4. Name it. Enter a clear Macro name — agents search by this, so be descriptive (more on naming below).
5. Write the response. Type your reply in the Response text section. This is where you add variables for personalization.
6. (Optional) Add tags. Under Add tags to ticket, attach any tags you want applied automatically.
7. (Optional) Add actions. Below the reply field, add macro Actions — for example, change the ticket status or edit a Shopify order.
8. Save. Click Create macro.

That's it. The macro now appears in the macro picker inside any ticket, ready to drop into a reply.

Variables: pulling Shopify and order data into a reply

This is where macros stop feeling like copy-paste and start feeling personal. Variables (also called placeholders or merge fields) are tokens like {{customer.first_name}} or {{order.tracking_url}} that Gorgias swaps for real data the moment the macro is applied (Macro Variables docs).

Write this once:

Hi {{customer.first_name}}, your order {{order.name}} is on its way! You can track it here: {{order.tracking_url}}.

…and every agent who applies it sends a message stitched together from that customer's live Shopify record — name, order number, tracking link — without touching the store admin.

Commonly used variables include the customer's first name, order number, order status, shipping address, and tracking number. Because Gorgias has a deep two-way Shopify integration, order-level data is available directly in the macro. For data living in a back-office tool connected via an HTTP integration, Gorgias exposes it through a path like ticket.customer.integrations[{{integration_id}}], where the integration_id is the number at the end of that integration's URL (Gorgias docs).

One pitfall worth flagging now: if the data a variable points to doesn't exist — say a pre-sale inquiry has no order attached — Gorgias replaces the variable with a blank space, not an error. So a careless template can fire off "Hi , your order is on its way!" That's the single most common macro embarrassment, and we'll cover how to avoid it in best practices.

Actions: what a macro can do beyond replying

Macro Actions are what separate Gorgias from a plain canned-response tool. When you apply a macro, it can perform operations on the ticket and your store in the same click. Per the Macro Actions documentation, these include:

• Add tags to the ticket (for reporting, filtering, or triggering downstream Rules).
• Set or change status — move the ticket to open, closed, or snoozed.
• Assign the ticket to a specific teammate or team.
• Add an internal note for context your customer never sees.
• Shopify actions (when your store is connected) — process a refund, refund shipping, or cancel, edit, or duplicate an order, right from the macro.

A practical example: a "Damaged item — reship" macro could send an apology with the customer's name, tag the ticket damaged, assign it to your fulfillment lead, set the status to open, and queue a duplicate order in Shopify — one click, five things done.

One behavior to know: when multiple macros with actions are applied to the same ticket, the actions execute in the order they were added (Gorgias docs). That matters if, say, a refund action and a status-change action could conflict.

Macro templates and the Macro Library

You don't have to build everything from scratch. Gorgias ships a Macro Library of default templates for typical ecommerce situations — order updates, return instructions, damaged-item reports, and similar (Macro templates docs). These are a sensible starting point: import one, then tweak the wording to match your brand voice and swap in your own variables. Treat them as scaffolding, not finished copy — generic template language is easy for customers to spot.

Using macros faster: shortcuts and recommendations

Two features make macros quick to apply at speed:

• Recommended macros. Gorgias surfaces the top three suggested macros for the ticket you're replying to, powered by a recommendation engine that blends machine-learning text similarity and classification with how often your team uses each macro (Gorgias docs).
• Keyboard shortcuts. Press cmd (ctrl) + 1, 2, or 3 to send one of those recommended macros without reaching for the mouse (Keyboard shortcuts docs). For a high-volume agent, that's the difference between a 30-second reply and a 3-second one.

Macros in Rules and automation

Macros aren't only for humans clicking buttons. They're a building block of Gorgias's automation, too.

In Rules — Gorgias's if-this-then-that engine — you can add an "Apply Macro" action so a macro fires automatically when conditions are met (Gorgias docs). For example: when a chat message matches the "where is my order" intent, apply the WISMO macro that sends tracking and tags the ticket. The same macro you built for agents now powers hands-off automation, which keeps your replies consistent whether a person or a Rule sent them.

This is the key mental model: a macro is the reusable content + action unit, and Rules are one of the ways you trigger it.

Macros and the Gorgias AI Agent

It's worth being precise about how macros relate to Gorgias's AI. The AI Agent is the newer, LLM-powered layer that reads a question in plain language, decides what the shopper wants, pulls live Shopify data, and resolves the ticket autonomously — it doesn't simply paste a fixed macro. Macros, by contrast, are deterministic: an agent or a Rule applies a specific saved reply.

In practice the two coexist. Your well-written macros and help-center articles become reference material and guardrails that shape consistent answers, while the AI Agent handles the messier natural-language tickets that don't map cleanly to one template. We cover that layer in depth in Gorgias AI Agent explained.

The honest distinction to keep in mind: a macro is still a templated reply that a human (or a Rule) sends — it speeds up the typing, but a person is in the loop deciding which macro to apply and clicking send. An AI agent layer goes a step further by resolving the conversation autonomously, drawing the answer from your connected knowledge and only escalating when it isn't confident. On a Shopify stack, that autonomous layer is Gorgias's own AI Agent. (One transparent aside: Macha is an AI agent layer of this kind, but it runs on Zendesk and Freshdesk only — it does not integrate with Gorgias, so if you're committed to Gorgias, Gorgias's AI Agent is your path. If you happen to run support on Zendesk or Freshdesk, you can try Macha free — 7-day free trial, no credit card required.)

Best practices for Gorgias macros

A few habits separate a macro library that scales from one that turns into clutter:

• Name macros so they're searchable. Use a consistent convention like [Returns] Start a return or [WISMO] Tracking link. Agents find macros by name under pressure; a vague name is a slow macro.
• Guard your variables. Only use order variables in macros that are meant for tickets with an order attached, or you'll send "Hi ," to a stranger. Keep separate pre-sale macros that don't reference order data.
• Bundle actions thoughtfully. Pair the reply with the tag, status, and assignment it logically needs — but don't over-automate a refund into a macro any agent might apply by reflex. Reserve destructive Shopify actions for clearly labeled macros.
• Tag consistently. Macro tags feed your reporting and your Rules. A clean, agreed tag taxonomy makes both far more useful.
• Prune regularly. Audit the library quarterly. Duplicate and stale macros dilute the recommendation engine and confuse agents. Fewer, sharper macros beat hundreds of near-duplicates.
• Start from templates, then make them yours. Use the Macro Library as a base, but rewrite the copy in your brand voice so replies don't read like form letters.

Common pitfalls to avoid

• Blank variables. Covered above — the number-one macro gotcha. Test each macro on a ticket without an order to see what it sends.
• Conflicting action order. Remember actions run in the order macros are added; stacking macros can produce surprising status or refund outcomes.
• Over-templated tone. Macros that are never personalized read as robotic. Variables plus a quick human edit keep them warm.
• Macro sprawl. Without governance, every agent makes their own near-identical macro and the library becomes unusable. Assign an owner.
• Assuming a macro "resolves" a ticket. A macro sends a reply; it doesn't think. For genuinely autonomous resolution you're relying on the AI Agent, not the macro itself.

Frequently asked questions

What is a macro in Gorgias? A macro is a saved, reusable response template that can also carry tags and actions. Applying one lets an agent send a personalized reply and, in the same click, tag the ticket, change its status, assign it, add an internal note, or trigger a Shopify action like a refund.

What's the difference between a Gorgias macro and a canned response? They're essentially the same idea — "canned response," "saved reply," and "template" are generic terms; Gorgias calls them Macros. The difference from a plain canned response is that Gorgias macros can bundle actions, not just text.

How do macro variables work in Gorgias? Variables like {{customer.first_name}} or {{order.tracking_url}} are placeholders that Gorgias replaces with live customer or Shopify order data when the macro is applied. If the underlying value is missing, Gorgias inserts a blank space, so use order variables only on tickets that have an order attached.

Can a Gorgias macro change ticket status or issue a refund? Yes. Macro actions can set status (open, closed, snoozed), assign the ticket, add tags or internal notes, and — when your Shopify store is connected — process refunds or cancel, edit, and duplicate orders.

Can macros run automatically? Yes. Beyond agents applying them manually (including via the cmd/ctrl + 1/2/3 shortcut for recommended macros), you can fire a macro automatically from a Rule using an "Apply Macro" action when conditions match.

Are macros the same as the Gorgias AI Agent? No. Macros are deterministic saved replies applied by a person or a Rule. The AI Agent is an LLM-powered layer that interprets and resolves tickets autonomously. See Gorgias AI Agent explained.

The bottom line

Gorgias Macros are the workhorse of an efficient ecommerce support team: saved templates that personalize themselves with Shopify variables and bundle the busywork — tags, status, assignment, even refunds — into one click. Organize them with clear names and a tight tag taxonomy, guard your variables against blanks, wire the right ones into Rules, and prune the library so the recommendation engine stays sharp. Just remember the ceiling: a macro speeds up a reply a human still chooses and sends. For tickets you want resolved end-to-end without an agent in the loop, that's the job of an AI agent layer — Gorgias's own AI Agent on a Shopify stack, or a Zendesk/Freshdesk-native layer elsewhere.

Verified against Gorgias's official Helpdesk Documentation, June 2026. Gorgias revises its interface and feature names periodically — confirm the exact labels and steps in your own account before relying on them.