How to Build Custom Gorgias Integrations With No Native App (2026)

Gorgias does let you reach external APIs natively through HTTP Integrations — you can pull data into the ticket and trigger calls from rules. That's genuinely useful. But each one is a manual build: you define the request, map the variables, and maintain it, and it fires on rules rather than being reasoned about by an AI agent in the moment.

If the tool you need has an API, there's a lighter path: connect it to Gorgias yourself, without an App Store listing and without hand-building an HTTP integration. This guide shows how, using AI-agent Custom Tools — you describe the action in plain English, and the same setup works across every help desk you run.

First, the framing. Macha isn't a Gorgias replacement — it runs on top of the Gorgias you already use. Your agents keep working in Gorgias with its rules, macros, and Shopify sidebar; Macha adds an AI layer that can read tickets, reason, and — through Custom Tools — reach into any other system to answer or act.

What "custom integration" actually means now

Historically, "integrating X with Gorgias" meant one of three things: find an App Store integration, build an HTTP Integration against the tool's API, or pay a developer for a bespoke build. All three work, and all three are heavy — an App Store app is someone else's idea of the integration; an HTTP Integration or bespoke build is a project you maintain.

A Custom Tool is a lighter path. Instead of building an app or a rule-fired HTTP call, you describe an action — "look up an order," "check a 3PL shipment," "cancel a subscription" — and point it at the relevant API endpoint. Your Macha AI agent then calls that action while it works a ticket, decides when it's relevant, passes the right parameters, and reasons over what comes back — no code, and the exact same setup works if you also run Zendesk, Shopify support, or another help desk.

The difference in practice is that the AI decides. An HTTP integration fires when a rule tells it to; a Custom Tool is chosen by the agent in context, based on what the customer actually asked.

The model in three steps

Every Custom Tool follows the same shape, whether it's wrapping Shopify, a 3PL API, or an internal microservice.

1. Point it at the API. You give Macha the endpoint, method, and credentials. If you'd rather not fill in a form, the built-in Sidekick will scaffold the whole thing from a plain-English description — "connect Stripe to look up payments," "hook up our internal orders API."

2. Define the action. Give the tool a label and a description the AI uses to decide when to call it, set the method and URL (with placeholders like {{order_id}} for the parameters the agent will fill), and choose whether it's a Read or a Write. Reads are safe lookups; Writes — refunds, cancellations, address changes — require confirmation before they run. Authentication, static headers, and response mapping are all here too, so a real production endpoint drops straight in.

3. The agent uses it live. Once the tool exists, your agent calls it mid-ticket. A customer asks "where's my order?" in Gorgias; the agent recognizes the intent, calls Get Order Status with the order ID it pulled from the conversation, and answers with the real status and tracking — grounded in your system of record, not a guess.

That's the entire loop: define once, and the AI decides when to use it on every relevant ticket thereafter.

What it looks like once you've built a few

Custom Tools aren't a one-off escape hatch — teams build a small library of them, grouped by the service they wrap. Here's a Macha workspace with tools for Postmark (list templates, send email) and a store's order-lookup endpoint, each tagged Read or Write with its API URL.

Notice the mix of GET/Read and POST/Write. An agent can be allowed to look up anything but only act — refund, cancel, update — with a confirmation step. That boundary is enforced per tool and per agent.

Read vs Write, auth, and staying safe

Because a Custom Tool can reach into real systems, the guardrails matter as much as the capability:

• Read vs Write. Read tools are free to call. Write tools (anything that changes state) require confirmation, so an agent can't silently issue a refund or cancel an order.
• Scoped by design. A tool exposes exactly one action against one endpoint. It does the job you defined and nothing else.
• Permissioned per agent. You decide which agents get which tools — your triage agent might only read; a senior-support agent might be allowed to write.
• Audited. Every call is logged, so you can see exactly what ran, with what inputs, and when.

For authentication, the builder supports the common patterns (API keys, bearer tokens, custom headers), so tools that need credentials — most of them — work without exposing secrets in the conversation.

When to use the App Store or an HTTP Integration vs a Custom Tool

Custom Tools don't make Gorgias's App Store or HTTP Integrations obsolete; they cover what's slow or missing.

• Reach for an App Store integration when a well-maintained one already exists — Shopify, a payment app, a loyalty tool — and does what you need. If Macha has a native connector for it, use that (it's deeper and zero-setup).
• Reach for a native HTTP Integration when you want a rule-triggered call that lives entirely inside Gorgias and you have the time to build and maintain it.
• Reach for a Custom Tool when you want the AI agent to decide when to call it, you'd rather not hand-build the request, the tool is internal or industry-specific, or you run more than one help desk and want the same action everywhere.

The honest rule of thumb: if you've ever said "I wish Gorgias could just check X for me," and X has an API, that's a Custom Tool.

Examples worth building

The pattern generalizes across every category of tool an e-commerce support team touches:

• Orders & fulfillment — look up an order or shipment in Shopify, a 3PL, or ShipStation and answer WISMO from source of truth.
• Subscriptions & billing — check or modify a subscription in Recharge, Chargebee, or Stripe.
• Warehouse & inventory — check stock or availability in your WMS before promising a customer.
• Engineering — open a Jira, Linear, or GitHub issue from a bug report and read its status back.
• Internal systems — hit your own admin API to look up an account, reset a flag, or trigger a job.

For a browsable list of tools you can connect this way — 200+ across CRM, databases, e-commerce, ITSM, and more — see the Custom Tools integration directory. If it has an API, it belongs on that list.

Running more than one help desk? The same approach works on Zendesk, Freshdesk, Front, and Intercom — Custom Tools are portable across all of them.

The bottom line

A missing App Store integration used to mean "not supported," and an HTTP Integration meant "build and maintain it yourself." With Custom Tools, it means "not yet — give me ten minutes." You describe the action, point it at the API, and your Gorgias AI agents can read and write it live inside a ticket, with Read/Write guardrails, per-agent permissions, and a full audit trail — and the same tool works across every help desk you run.

Ready to try it? See how Custom Tools work, browse the integration directory, or start a free trial and wire up your first tool today.

Frequently asked questions

Do I need an engineer to build a Custom Tool for Gorgias? No. You describe the integration in plain English and Macha's Sidekick scaffolds the request, authentication, and parameters. Technical teams can go deeper with full control over methods, headers, bodies, and response mapping.

How is this different from Gorgias HTTP Integrations? Gorgias HTTP Integrations are native, rule-triggered API calls you build and maintain inside Gorgias. A Custom Tool is chosen by the AI agent in context — it decides when to call it based on what the customer asked — is no-code to set up, and works the same across every help desk you run.

Is this a Gorgias App Store app? No. A Custom Tool doesn't need an App Store listing. It's an action your AI agent calls against any API, so you can connect tools that will never have a native integration, including internal and industry-specific systems.

Can it change data, or only read it? Both. Read tools are safe lookups; Write tools (refunds, cancellations, address changes) require a confirmation step before they run, and you control which agents can use them.

Is it secure? Yes. Custom Tools are scoped to a single action, permissioned per agent, and every call is audited — so you always know what ran, with what inputs, and when.