N8n Workflow Automation with Claude: Email Triage and Routing in 30 Minutes

By the end of this tutorial, you’ll have a working n8n Claude email automation workflow that reads incoming emails, uses Claude to classify urgency and category, and routes them to the right Slack channel or team inbox — without writing a single backend service. The whole thing runs in about 30 minutes if you have your API keys ready.

Email triage is one of those problems that looks trivial until you’re dealing with 200 messages a day across support, sales, and billing threads. Keyword rules break constantly. Rule-based routing misses context. Claude actually reads the email and understands what the person wants — which is the difference between routing “my account was charged twice” to billing (correct) vs. general support (wrong, and annoying for the customer).

Here’s the overview before we dive in:

1. Connect your email trigger — Pull new emails from Gmail or IMAP into n8n
2. Build the Claude classification node — Send subject + body to Claude with a structured prompt
3. Parse the JSON response — Extract category, urgency, and suggested action
4. Add routing logic — Switch node to fan out based on classification
5. Wire up destinations — Post to Slack channels or forward to team inboxes
6. Test and harden — Handle edge cases and malformed responses

What You’re Actually Building

The workflow triggers on new email, passes the sender, subject, and body to Claude Haiku (the cost-efficient choice here — more on that shortly), receives a structured JSON classification, and routes based on the result. A billing escalation goes to #billing-urgent. A generic sales inquiry goes to a CRM webhook. An automated notification gets archived silently.

Running this on Claude Haiku costs roughly $0.0008–$0.002 per email depending on body length, at current input pricing of $0.80/million tokens. For a team processing 500 emails/day, you’re looking at under $1/day. If you need better reasoning on complex enterprise threads, bump to Claude Sonnet 3.5 — about 5x the cost but meaningfully better at nuanced context. I’d use Haiku for 80% of emails and only escalate to Sonnet when confidence is low.

If you haven’t settled on which platform to use for your automation stack, the n8n vs Make vs Zapier comparison for Claude workflows is worth reading before you commit — n8n’s self-hosted option is the main reason I’m using it here.

Step 1: Connect Your Email Trigger

In n8n, create a new workflow and add a Gmail Trigger node (or IMAP Email node if you’re not on Google Workspace). For Gmail, you’ll need OAuth2 credentials — n8n’s credential store handles this cleanly.

Configure the trigger:

• Poll interval: Every 1 minute for near-real-time, or every 5 minutes if you want to batch
• Label filter: “INBOX” to catch everything, or a specific label if you pre-filter
• Mark as read: Yes — prevents reprocessing on the next poll

The output you’ll use downstream: subject, text (plain body), from.value[0].address, and date.

One thing the n8n docs understate: Gmail’s API has a 250 quota units/second limit per project. If you’re processing high volumes, you’ll hit rate limit errors. Mitigate this by setting poll interval to 5 minutes and processing in batches rather than per-email triggers.

Step 2: Build the Claude Classification Node

Add an HTTP Request node. n8n doesn’t have a native Claude node (as of mid-2025), so you’re calling the Anthropic API directly. This is actually fine — it gives you full control over the request.

Configure the HTTP Request node:

• Method: POST
• URL: https://api.anthropic.com/v1/messages
• Authentication: Header Auth → Header Name: x-api-key, Value: your Anthropic API key (stored as n8n credential)

In the Headers, add:

• anthropic-version: 2023-06-01
• content-type: application/json

For the body, use the JSON body type and use n8n’s expression editor to build it dynamically:

{
  "model": "claude-haiku-4-5",
  "max_tokens": 300,
  "system": "You are an email triage assistant. Classify emails and return ONLY valid JSON with no other text. Never include explanations outside the JSON object.",
  "messages": [
    {
      "role": "user",
      "content": "Classify this email and return JSON with these exact fields: category (one of: billing, support, sales, partnership, spam, internal, other), urgency (one of: critical, high, normal, low), sentiment (one of: frustrated, neutral, positive), requires_human (boolean), summary (max 20 words), suggested_team (one of: billing, support, sales, leadership, archive).\n\nFrom: {{ $json.from.value[0].address }}\nSubject: {{ $json.subject }}\nBody: {{ $json.text.substring(0, 1500) }}"
    }
  ]
}

The substring(0, 1500) cap is intentional. Most of the signal for triage is in the first 1500 characters. Truncating here keeps token costs low and avoids sending boilerplate email footers to the model. For emails with attachments you care about, you’ll need a separate extract step — out of scope here but worth noting.

The system prompt constraint (“return ONLY valid JSON”) is doing real work. Without it, Claude will occasionally wrap the output in markdown code fences or add a sentence of preamble. For more on writing system prompts that produce consistent structured behavior, see system prompts that actually work for Claude agents.

Step 3: Parse the JSON Response

Add a Code node after the HTTP Request. Claude’s response comes back as content[0].text — a string you need to parse.

// n8n Code node (JavaScript)
const responseText = $input.first().json.content[0].text.trim();

let classification;
try {
  // Strip markdown code fences if Claude wrapped it anyway
  const cleaned = responseText.replace(/^```json\n?/, '').replace(/\n?```$/, '');
  classification = JSON.parse(cleaned);
} catch (e) {
  // Fallback classification when JSON parsing fails
  classification = {
    category: "other",
    urgency: "normal",
    sentiment: "neutral",
    requires_human: true,
    summary: "Classification failed — needs manual review",
    suggested_team: "support",
    parse_error: true
  };
}

// Merge with original email data
return [{
  json: {
    ...classification,
    original_subject: $input.first().json.subject || "",
    original_from: $input.first().json.from?.value?.[0]?.address || "",
    original_date: $input.first().json.date || "",
    raw_classification: responseText
  }
}];

The fallback classification is important. In production, about 1-2% of Claude responses will fail to parse cleanly — usually when the email body contains unusual characters or when the model gets confused by a very long footer. Always fail safe to human review rather than dropping the email silently. This pattern is discussed in more detail in our guide on reducing LLM hallucinations in production with structured outputs.

Step 4: Add Routing Logic with a Switch Node

Add a Switch node after the Code node. Route on the suggested_team field.

Configure output branches:

• billing: {{ $json.suggested_team === 'billing' }}
• support: {{ $json.suggested_team === 'support' }}
• sales: {{ $json.suggested_team === 'sales' }}
• leadership: {{ $json.suggested_team === 'leadership' }}
• archive: {{ $json.suggested_team === 'archive' }}

Add a secondary urgency check on the billing and support branches: if urgency === 'critical', route to a separate #urgent Slack channel before the normal path. You can nest Switch nodes or use an IF node inline — both work, nested Switch is cleaner to read.

Step 5: Wire Up Destinations

For each branch, add a Slack node. Here’s the message template for the support branch — adapt for others:

{
  "channel": "#support-queue",
  "text": ":email: *New {{ $json.urgency }} priority email*",
  "blocks": [
    {
      "type": "section",
      "text": {
        "type": "mrkdwn",
        "text": "*From:* {{ $json.original_from }}\n*Subject:* {{ $json.original_subject }}\n*Summary:* {{ $json.summary }}\n*Sentiment:* {{ $json.sentiment }}\n*Requires human:* {{ $json.requires_human }}"
      }
    },
    {
      "type": "actions",
      "elements": [
        {
          "type": "button",
          "text": { "type": "plain_text", "text": "Open in Gmail" },
          "url": "https://mail.google.com/mail/u/0/#inbox"
        }
      ]
    }
  ]
}

For the archive branch, use the Gmail node with the “Modify” action to apply a label (e.g., “Auto-Archived”) and mark as read. No Slack notification needed — this is your noise filter.

For sales leads, consider routing to a CRM webhook (HubSpot, Pipedrive, etc.) instead of Slack. Add an HTTP Request node posting to your CRM’s contact or deal creation endpoint with the sender email and summary as the description.

Step 6: Test and Harden

Run the workflow manually on a sample of 20 real emails before enabling the trigger. Check the classification accuracy — in my testing, Claude Haiku gets the category right about 91% of the time on business email. It struggles most with:

• Emails that are both billing AND support (charge dispute) — it picks one; handle this by checking if category === 'billing' AND suggested_team === 'support'
• Internal emails from colleagues that discuss customers — it may classify as support
• Marketing newsletters that appear transactional — it may not catch them as spam

Add an Error Trigger workflow node in n8n to catch workflow execution failures and post to a #automation-errors Slack channel. You want visibility when the Anthropic API returns a 529 (overloaded) or your Gmail OAuth token expires. For production resilience patterns, the guide on LLM fallback and retry logic covers exactly this — including exponential backoff for transient API errors.

Common Errors and How to Fix Them

Error 1: “Cannot read property ‘text’ of undefined” in Code node

This means the Anthropic API call returned an error response (4xx or 5xx) and content[0] doesn’t exist. Add a check before parsing:

const response = $input.first().json;

// Check for API error response
if (response.error || !response.content || !response.content[0]) {
  return [{
    json: {
      category: "other",
      urgency: "normal",
      requires_human: true,
      summary: "API error — manual review required",
      suggested_team: "support",
      api_error: response.error?.message || "Unknown API error"
    }
  }];
}

const responseText = response.content[0].text.trim();
// ... rest of parsing

Error 2: Emails being processed multiple times

Gmail Trigger’s deduplication relies on the message ID, but if the workflow fails mid-execution, n8n can re-trigger on the same email. Fix: use an n8n Set node to write the message ID to a simple key-value store (n8n’s built-in static data or an external Redis node), and add an IF node at the start to skip already-processed IDs.

Error 3: Claude returning inconsistent field names

Occasionally Haiku returns team instead of suggested_team, or priority instead of urgency. Add normalization in the Code node:

// Normalize inconsistent field names from Claude
classification.suggested_team = classification.suggested_team 
  || classification.team 
  || classification.routing_team 
  || "support";

classification.urgency = classification.urgency 
  || classification.priority 
  || "normal";

This is a quirk of using smaller models for structured output tasks. Claude Sonnet 3.5 is far more consistent about following the exact field schema you specify, which is worth the cost if you’re processing high volumes where routing errors are expensive.

What to Build Next

The immediate extension is auto-draft replies. Once you know an email is a billing inquiry, you have enough context to generate a first-draft response using the customer’s name, the specific issue summary, and a template. Add a second Claude call (Sonnet, not Haiku — you want quality here) that generates a draft, then use Gmail’s “Create Draft” action to queue it for human review before sending. This gets your support team to 3-click replies on routine queries instead of writing from scratch.

For teams processing support at scale, the patterns in automating customer support with Claude agents go deeper on confidence thresholds, human-in-the-loop escalation, and measuring deflection rates — worth reading once this workflow is live.

Bottom line by reader type:

• Solo founder handling your own inbox: Run this on n8n Cloud ($20/month) with Claude Haiku. You’ll save 30+ minutes daily and nothing will fall through the cracks.
• Small support team (2-10 people): Self-host n8n on a $5 VPS, run Haiku for triage, add the draft-reply extension. ROI is measurable within a week.
• Enterprise / compliance-sensitive: Self-hosted n8n is non-negotiable for email data. Consider whether you need to log Claude inputs/outputs to your own storage for audit purposes before enabling this in production. The n8n Claude email automation pattern works well here — just add a logging node before the archive step.