How to Automate Zendesk Support with AI Using n8n and RAG

Your support team is drowning in repetitive tickets while customers wait hours for answers that already exist in your knowledge base. Password resets, shipping questions, “how do I cancel” — the same 20 questions eating up 80% of your agents’ time. What if every new Zendesk ticket got an accurate, knowledge-base-backed AI reply within seconds, and only the genuinely tricky ones reached a human?

That’s exactly what you’ll build in this guide. Using n8n, OpenAI, Supabase, and a RAG (Retrieval-Augmented Generation) pipeline, you’ll create a workflow that reads every incoming Zendesk ticket, searches your knowledge base for relevant answers, generates a professional reply, and posts it directly to the ticket — automatically. When the AI doesn’t have a confident answer, it escalates to your human team with a clear tag so nothing falls through the cracks.

Prefer to skip the setup? Grab the ready-made template and be up and running in under 10 minutes.

What You’ll Build

1. A new ticket arrives in Zendesk — the workflow fires instantly via webhook.
2. The AI agent searches your Supabase-hosted knowledge base using vector similarity (RAG) and drafts a response grounded in your actual documentation.
3. If the knowledge base has a solid answer, the AI posts the reply directly to the Zendesk ticket and tags it ai_reply.
4. If the AI can’t find relevant information, it tags the ticket human_requested so your team picks it up — no guessing, no hallucinations.
5. Every conversation is stored in Postgres memory, so follow-up tickets from the same customer retain context.

How It Works — The Big Picture

The entire workflow is a single n8n pipeline with a smart routing branch at the end. Here’s the flow from ticket to resolution:

┌──────────────────────────────────────────────────────────────────────────────┐
│  AI-POWERED ZENDESK SUPPORT WITH RAG                                        │
│                                                                              │
│  [Zendesk Webhook] → [Extract Ticket Data] → [RAG AI Agent]                │
│                                                     │                        │
│                                        ┌────────────┴────────────┐          │
│                                         │  Check If Escalation    │         │
│                                        │      Needed             │          │
│                                        └────┬──────────┬─────────┘          │
│                                     YES ↓              ↓ NO                  │
│                               [Tag: human_      [Post AI Reply]             │
│                                requested]              ↓                     │
│                                                  [Tag: ai_reply]            │
│                                                                              │
│  Sub-components of the RAG AI Agent:                                        │
│  ┌──────────────────────────────────────────────┐                            │
│  │ [OpenAI GPT-4o-mini]  [Postgres Memory]      │                           │
│  │ [Knowledge Base Tool → Supabase Vectors]     │                           │
│  │ [OpenAI Embeddings]                         │                           │
│  └──────────────────────────────────────────────┘                           │
└──────────────────────────────────────────────────────────────────────────────┘
  

What You’ll Need

• n8n — self-hosted or n8n Cloud (any plan)
• Zendesk — any plan with API access and trigger/webhook support
• OpenAI API key — for GPT-4o-mini (chat) and text-embedding-3-small (embeddings)
• Supabase account — free tier works; you’ll need a project with pgvector enabled for the vector store
• PostgreSQL database — Supabase’s built-in Postgres works, or any external Postgres instance for conversation memory
• Your knowledge base content — FAQ articles, product docs, troubleshooting guides already written and ready to embed

Estimated build time: 45–60 minutes from scratch, or under 10 minutes with the template.

Part 1 — Receiving and Parsing Zendesk Tickets

1 Receive New Ticket (Webhook)

This node listens for incoming HTTP POST requests from Zendesk. Every time a new ticket is created, Zendesk’s trigger sends the ticket data to this webhook URL.

1. Add a Webhook node to your canvas.
2. Set the HTTP Method to POST.
3. Set the Path to zendesk-new-ticket (or any slug you prefer).
4. Copy the generated webhook URL — you’ll paste this into Zendesk’s trigger configuration.

When a ticket arrives, the webhook receives a JSON payload like this:

{
  "body": {
    "ticket_id": "48291",
    "ticket_status": "new",
    "requester_name": "Sarah Thompson",
    "requester_email": "sarah.thompson@gmail.com",
    "subject": "Can't reset my password",
    "description": "Hi, I've been trying to reset my password for the last hour but the reset email never arrives. I've checked spam. Can you help?"
  }
}

2 Extract Ticket Data (Set Node)

The raw webhook payload is nested inside body. This Set node extracts the fields you need into clean, top-level variables that the rest of the workflow can reference easily.

1. Add a Set node after the Webhook.
2. Create assignments for: ticket_id, ticket_status, requester_name, requester_email, subject, description, and timestamp.
3. For description, use the expression {{ ($json.body.description || '').split('\n\n').slice(-1)[0].trim() }} — this strips quoted reply chains and keeps only the customer’s latest message.
4. For timestamp, use {{ $now.format('yyyy-MM-dd HH:mm') }} so you have a record of when the workflow processed the ticket.

After this node, the data flowing forward looks like:

{
  "ticket_id": "48291",
  "ticket_status": "new",
  "requester_name": "Sarah Thompson",
  "requester_email": "sarah.thompson@gmail.com",
  "subject": "Can't reset my password",
  "description": "I've been trying to reset my password for the last hour but the reset email never arrives. I've checked spam. Can you help?",
  "timestamp": "2026-04-10 14:23"
}

Part 2 — The RAG AI Agent

This is the brain of the workflow. The AI Agent node connects to three sub-components: a language model (GPT-4o-mini), a conversation memory (Postgres), and a knowledge base retrieval tool (Supabase vector store). Together, they form a RAG pipeline that grounds every response in your actual documentation.

3 Generate AI Response (AI Agent)

The Agent node receives the customer’s ticket and orchestrates the entire reasoning process. It decides whether to search the knowledge base, reads the results, and composes a professional reply.

1. Add an AI Agent node.
2. Set the Prompt Type to Define.
3. Set the input text to:
   Customer: {{ $json.requester_name }}
Subject: {{ $json.subject }}
Message: {{ $json.description }}
4. In the System Message, paste the following instructions that tell the agent how to behave:

You are a professional, empathetic customer support agent. Your job is to help
customers by answering their questions accurately using ONLY the information
from the retrieved knowledge base documents.

Rules:
1. Always be polite, professional, and concise.
2. If the knowledge base contains a clear answer, provide it with step-by-step
   instructions when appropriate.
3. If the knowledge base does NOT contain relevant information, respond with
   EXACTLY: "I will escalate this to our support team who will get back to
   you shortly."
4. Never make up information. Never guess. Only use verified KB content.
5. Sign off with: "Best regards, Support Team"

4 OpenAI Chat Model (Sub-node)

This is the language model that powers the agent’s reasoning. It connects to the Agent node’s ai_languageModel input.

1. Add an OpenAI Chat Model node below the Agent.
2. Select gpt-4o-mini as the model — it’s fast, cheap, and accurate enough for support responses.
3. Set temperature to 0.3 — low enough to keep answers factual, high enough to sound natural.
4. Set max tokens to 1024 — more than enough for a support reply.
5. Connect your OpenAI API credential.

5 Ticket Conversation Memory (Postgres)

This memory node stores the conversation history for each ticket ID in a Postgres table called zendesk_ticket_histories. If a customer sends a follow-up message on the same ticket, the AI remembers what was discussed before.

1. Add a Postgres Chat Memory node.
2. Set the table name to zendesk_ticket_histories.
3. Set the Session Key to {{ $('Extract Ticket Data').item.json.ticket_id }} — this groups messages by ticket.
4. Connect your Postgres credential (Supabase’s built-in Postgres works perfectly here).

The table is created automatically on first run. It stores each message exchange so the agent has full context for multi-message tickets.

6 Knowledge Base Retrieval Tool (Vector Store)

This is the RAG component. The tool searches your Supabase vector store for the most relevant knowledge base articles and feeds them to the AI agent as context.

1. Add a Vector Store Tool node and name it “Retrieve Knowledge Base”.
2. Set the tool name to knowledge_base.
3. Set Top K to 5 — the agent will receive the 5 most relevant document chunks.
4. Write a clear description: “Contains all company knowledge base articles, FAQs, product documentation, and troubleshooting guides.”

7 Supabase Vector Store + OpenAI Embeddings

The Vector Store Tool needs two sub-components: a vector store (where your documents live) and an embedding model (to convert the search query into a vector).

1. Add a Supabase Vector Store node. Set the table to documents and the query function to match_documents.
2. Add an OpenAI Embeddings node. Set the model to text-embedding-3-small with 1536 dimensions.
3. Wire the Embeddings node into the Vector Store’s ai_embedding input.
4. Wire the Vector Store into the Retrieve Knowledge Base tool’s ai_vectorStore input.

Part 3 — Smart Routing and Zendesk Actions

After the AI generates a response, the workflow needs to decide: was the response a confident answer, or did the AI punt because it couldn’t find relevant information?

8 Check If Escalation Needed (IF Node)

This IF node inspects the AI’s output text. If it contains the escalation phrases (“will escalate this” or “get back to you shortly”), the ticket goes to the human escalation path. Otherwise, it proceeds to auto-reply.

1. Add an IF node after the AI Agent.
2. Set the condition combinator to OR.
3. Condition 1: {{ $json.output }} contains will escalate this
4. Condition 2: {{ $json.output }} contains get back to you shortly
5. Set case sensitivity to false.

The True branch (escalation needed) goes to the human tagging node. The False branch (AI answered) goes to the reply-posting node.

9 Tag as Human Escalation (True Branch)

When the AI can’t find an answer, this HTTP Request node calls the Zendesk API to tag the ticket with human_requested and ai_escalated. Your support team can create a Zendesk view filtered by these tags to see exactly which tickets need human attention.

1. Add an HTTP Request node on the True output.
2. Set Method to PUT.
3. Set URL to: https://YOUR_ZENDESK_DOMAIN.zendesk.com/api/v2/tickets/{{ $('Extract Ticket Data').first().json.ticket_id }}/tags.json
4. Set the JSON body to: { "tags": ["human_requested", "ai_escalated"] }
5. Set authentication to Predefined Credential Type → Zendesk API.

10 Post AI Reply to Ticket (False Branch)

When the AI has a confident answer, this node posts it as a public comment on the Zendesk ticket and sets the ticket status to “pending” (awaiting customer confirmation).

1. Add an HTTP Request node on the False output.
2. Set Method to PUT.
3. Set URL to: https://YOUR_ZENDESK_DOMAIN.zendesk.com/api/v2/tickets/{{ $('Extract Ticket Data').first().json.ticket_id }}.json
4. Set the JSON body to:

{
  "ticket": {
    "comment": {
      "body": "{{ AI agent's output text }}",
      "public": true
    },
    "status": "pending"
  }
}

The "public": true flag means the customer sees this reply in their email and in the Zendesk portal. Setting status to "pending" tells Zendesk to wait for the customer’s next response.

11 Tag as AI Reply

After posting the reply, this final node tags the ticket with ai_reply and auto_resolved. This lets you track how many tickets the AI handles versus humans, and gives you data for measuring automation ROI.

1. Add one more HTTP Request node after the reply node.
2. Same pattern: PUT to the /tags.json endpoint.
3. Body: { "tags": ["ai_reply", "auto_resolved"] }

The Data Structure

The workflow relies on two persistent data stores: the Supabase vector store for knowledge base content, and the Postgres table for conversation memory.

Supabase documents Table

Postgres zendesk_ticket_histories Table

Full System Flow

┌─────────────────────────────────────────────────────────────────────────────┐
│  END-TO-END: TICKET ARRIVES → RESOLUTION                                   │
│                                                                             │
│  Customer creates ticket in Zendesk                                        │
│       ↓                                                                     │
│  Zendesk Trigger fires webhook POST                                        │
│       ↓                                                                     │
│  [Receive New Ticket] — n8n webhook catches the request                    │
│       ↓                                                                     │
│  [Extract Ticket Data] — pull ticket_id, subject, description, etc.        │
│       ↓                                                                     │
│  [Generate AI Response] ← GPT-4o-mini + Postgres Memory                   │
│       │                  ← Knowledge Base Tool                              │
│       │                     ↑                                               │
│       │              [Supabase Vectors] ← [OpenAI Embeddings]              │
│       ↓                                                                     │
│  [Check If Escalation Needed]                                              │
│       │                                                                     │
│   YES ├──→ [Tag: human_requested] → Human agent picks up ticket            │
│       │                                                                     │
│    NO └──→ [Post AI Reply to Ticket] → Customer gets instant answer        │
│                    ↓                                                        │
│            [Tag: ai_reply] → Track AI resolution rate                      │
└─────────────────────────────────────────────────────────────────────────────┘
  

Testing Your Workflow

1. Activate the workflow in n8n (toggle the Active switch).
2. Create a test ticket in Zendesk with a question your knowledge base can answer — for example, “How do I reset my password?”
3. Check the n8n execution log — you should see the webhook trigger, data extraction, AI agent processing, and the reply being posted.
4. Open the Zendesk ticket — verify the AI’s reply appears as a public comment and the ticket has the ai_reply tag.
5. Create a second test ticket with a question your KB does NOT cover — like “Can I get a refund for my order #12345?”
6. Verify escalation — the ticket should have the human_requested tag and no AI reply posted.

Frequently Asked Questions

What’s Next?

• Add a satisfaction survey — after the AI replies, send a follow-up asking the customer to rate the response. Use the rating to fine-tune your KB.
• Build a KB ingestion pipeline — automate the process of embedding new documentation into Supabase whenever you publish a new help article.
• Add Slack notifications for escalations — when a ticket is tagged human_requested, send a Slack message to your support channel so agents can pick it up immediately.
• Track AI resolution rate — build a simple dashboard (Google Sheets or Metabase) that counts ai_reply vs human_requested tags over time to measure your automation ROI.