Multilingual customer support ticket automation with response drafting and routing

Customer support teams managing multilingual tickets face a familiar bottleneck: each incoming message requires a human to read it, translate it if needed, draft a response, and route it to the right department. When your customers span multiple languages and time zones, this manual process creates delays and inconsistencies.......

The good news is that you can automate most of this work without losing quality. By combining ChatGPT Writer for intelligent response drafting, ElevenLabs for voice quality assurance, and Immersive Translate AI for language detection and translation, you can build a workflow that ingests a support ticket in any language, drafts a contextually appropriate response, translates it back to the customer's language, and routes it to the correct team, all without touching a keyboard. For more on this, see Wispr Flow AI vs ChatGPT Writer vs HyperWrite: AI Writing....

This guide walks you through building this system using either Zapier, n8n, Make, or Claude Code as your orchestration layer. We'll focus on n8n for detailed examples since it offers the best balance of transparency and control for intermediate users, but we'll flag where the other tools differ in their approaches.

The Automated Workflow

Architecture Overview

Your workflow will follow this sequence:

1. A support ticket arrives (via email, form submission, or API webhook).
2. Immersive Translate AI detects the language and translates to English if needed.
3. ChatGPT Writer drafts a response based on ticket content and your guidelines.
4. The draft is translated back to the customer's original language.
5. ElevenLabs generates an audio version for quality review (optional but recommended).
6. The ticket is tagged and routed to the appropriate team based on content analysis.
7. A notification is sent to your support lead with the draft, audio preview, and suggested routing.

Choosing Your Orchestration Tool

n8n is ideal if you want to self-host and maintain full control over your data. Its visual node-based editor is intuitive, and it handles complex conditional logic well.

Zapier is best if you want managed hosting and don't mind paying per task. It's faster to set up and requires no infrastructure, but offers less transparency into data flow.

Make (Integromat) sits in the middle; it's cloud-hosted but cheaper than Zapier for high-volume workflows and offers reasonable flexibility.

Claude Code (via Claude's API and a wrapper like Replit or Render) is best if you prefer writing Python or JavaScript instead of clicking visual nodes. It also gives you access to Claude Opus 4.6 for more nuanced response generation.

For this guide, we'll build primarily in n8n with notes on adapting to other platforms.

Step 1:

Setting Up the Webhook Trigger

Every workflow needs an entry point. If you're pulling tickets from an existing system (Zendesk, Freshdesk, Help Scout), you can poll their API. For real-time processing, a webhook is faster.

In n8n, create a new workflow and add a Webhook trigger node.

Copy
Name: Support Ticket Received
Method: POST
Path: /support-ticket-webhook
Authentication: Basic Auth (set a username and password)

Configure the webhook to accept this JSON payload:

Copy{
  "ticket_id": "TKT-12345",
  "customer_email": "customer@example.com",
  "customer_name": "Jane Smith",
  "message": "Bonjour, je ne peux pas accéder à mon compte...",
  "category": "account_access",
  "priority": "medium"
}

Zapier equivalent: Use the Webhooks by Zapier trigger and note down the webhook URL it provides. Same authentication applies.

Make equivalent: Use the Webhooks module under the HTTP group.

Step 2:

Language Detection with Immersive Translate AI

Once the webhook fires, the first node detects which language the incoming message uses. Immersive Translate AI's API endpoint is:

Copy
POST https://api.immersive-translate.com/detect

In n8n, add an HTTP Request node configured as follows:

Copy
Method: POST
URL: https://api.immersive-translate.com/detect
Headers:
  Authorization: Bearer YOUR_IMMERSIVE_TRANSLATE_API_KEY
  Content-Type: application/json
Body (JSON):
{
  "text": "{{ $json.message }}"
}

The API responds with:

Copy{
  "language": "fr",
  "confidence": 0.95,
  "detected_language_name": "French"
}

Store this response in a variable; you'll need the detected language code later.

Step 3:

Translation to English

If the detected language is not English, translate the message using Immersive Translate AI's translation endpoint:

Copy
POST https://api.immersive-translate.com/translate

Add a conditional node in n8n to check if the detected language is English. If not, add another HTTP Request node:

Copy
Method: POST
URL: https://api.immersive-translate.com/translate
Headers:
  Authorization: Bearer YOUR_IMMERSIVE_TRANSLATE_API_KEY
  Content-Type: application/json
Body (JSON):
{
  "text": "{{ $json.message }}",
  "source_language": "{{ $json.detected_language }}",
  "target_language": "en"
}

Store the translated text in a new variable called message_english. If English was already detected, skip this step and use the original message.

Step 4:

Response Drafting with ChatGPT Writer

Now that you have the message in English, use ChatGPT Writer to draft a contextually appropriate response. ChatGPT Writer doesn't have a traditional API endpoint; instead, you'll use OpenAI's Chat Completions API directly, which is what ChatGPT Writer uses under the hood.

Add an HTTP Request node in n8n:

Copy
Method: POST
URL: https://api.openai.com/v1/chat/completions
Headers:
  Authorization: Bearer YOUR_OPENAI_API_KEY
  Content-Type: application/json
Body (JSON):
{
  "model": "gpt-4o",
  "temperature": 0.7,
  "max_tokens": 500,
  "messages": [
    {
      "role": "system",
      "content": "You are a professional customer support agent for a SaaS platform. Your responses are empathetic, clear, and actionable. Keep responses to 150-200 words. If the issue is urgent or critical, flag it explicitly at the end with [URGENT]."
    },
    {
      "role": "user",
      "content": "Support Ticket Category: {{ $json.category }}\n\nCustomer Message: {{ $json.message_english }}\n\nDraft a response addressing the customer's concern."
    }
  ]
}

The response will be:

Copy{
  "choices": [
    {
      "message": {
        "content": "Hi Jane, thank you for reaching out. I understand account access issues are frustrating. Let me help you troubleshoot..."
      }
    }
  ]
}

Extract the content and store it as draft_response.

Step 5:

Back-Translation to Original Language

Translate the draft response back to the customer's original language using Immersive Translate AI again:

Copy
POST https://api.immersive-translate.com/translate

Add another HTTP Request node:

Copy
Method: POST
URL: https://api.immersive-translate.com/translate
Headers:
  Authorization: Bearer YOUR_IMMERSIVE_TRANSLATE_API_KEY
  Content-Type: application/json
Body (JSON):
{
  "text": "{{ $json.draft_response }}",
  "source_language": "en",
  "target_language": "{{ $json.detected_language }}"
}

Store the translated response as draft_response_translated.

Step 6:

Audio Generation with ElevenLabs

For quality assurance and accessibility, generate an audio version of the draft in the customer's language. ElevenLabs' API endpoint:

Copy
POST https://api.elevenlabs.io/v1/text-to-speech/{voice_id}

First, you need to select or create a voice. For multilingual support, ElevenLabs offers language-specific voices. Add an HTTP Request node:

Copy
Method: POST
URL: https://api.elevenlabs.io/v1/text-to-speech/21m00Tcm4TlvDq8ikWAM
Headers:
  xi-api-key: YOUR_ELEVENLABS_API_KEY
  Content-Type: application/json
Body (JSON):
{
  "text": "{{ $json.draft_response_translated }}",
  "model_id": "eleven_multilingual_v2",
  "voice_settings": {
    "stability": 0.5,
    "similarity_boost": 0.75
  }
}

The response contains an audio stream. Store it as a file in your storage system (AWS S3, local file, etc.) and generate a URL for later reference.

In n8n, you can pipe the response directly to a file write operation:

Copy
node.binary.audio = response.body;

Step 7:

Routing Logic

Analyse the ticket category and content to route to the correct team. Add a Switch node (conditional logic) in n8n:

Copy
Condition 1: If $json.category === "account_access" → Route to "Account Team"
Condition 2: If $json.category === "billing" → Route to "Finance Team"
Condition 3: If $json.draft_response contains "[URGENT]" → Route to "Priority Queue"
Default: Route to "General Support"

For each route, add a Send Email or HTTP POST node that notifies the assigned team.

Step 8:

Notification and Handoff

Send a summary email to your support lead with:

• Ticket ID and customer name
• Original message (original language)
• Detected language and confidence score
• Proposed response (original language)
• Audio preview link
• Suggested routing
• A button to approve and send or edit and resend

Add an Email node in n8n (Gmail, SendGrid, or your email provider):

Copy
To: support-lead@company.com
Subject: [DRAFT] TKT-{{ $json.ticket_id }} - {{ $json.customer_name }}
Body:
Customer: {{ $json.customer_name }} ({{ $json.customer_email }})
Detected Language: {{ $json.detected_language_name }}
Category: {{ $json.category }}
Priority: {{ $json.priority }}

--- ORIGINAL MESSAGE ---
{{ $json.message }}

--- PROPOSED RESPONSE (translated to {{ $json.detected_language_name }}) ---
{{ $json.draft_response_translated }}

--- AUDIO PREVIEW ---
Listen here: {{ $json.audio_url }}

--- SUGGESTED ROUTING ---
Team: {{ $json.suggested_team }}

Approve and Send | Edit | Reassign

Alternatively, post this to a Slack channel for real-time visibility:

Copy
POST https://hooks.slack.com/services/YOUR/SLACK/WEBHOOK

Body:

Copy{
  "channel": "#support-drafts",
  "username": "Support Automation",
  "text": "New draft ready for review",
  "blocks": [
    {
      "type": "section",
      "text": {
        "type": "mrkdwn",
        "text": "*Ticket:* TKT-{{ $json.ticket_id }}\n*Customer:* {{ $json.customer_name }}\n*Language:* {{ $json.detected_language_name }}\n*Category:* {{ $json.category }}"
      }
    },
    {
      "type": "section",
      "text": {
        "type": "mrkdwn",
        "text": "*Proposed Response:*\n{{ $json.draft_response_translated }}"
      }
    },
    {
      "type": "actions",
      "elements": [
        {
          "type": "button",
          "text": {
            "type": "plain_text",
            "text": "Send As Is"
          },
          "value": "send",
          "action_id": "send_draft"
        },
        {
          "type": "button",
          "text": {
            "type": "plain_text",
            "text": "Edit Before Sending"
          },
          "value": "edit",
          "action_id": "edit_draft"
        }
      ]
    }
  ]
}

Putting It All Together:

Full n8n Workflow

Here's the complete node sequence:

1. Webhook (Support Ticket Received)
2. HTTP Request (Immersive Translate AI: Language Detection)
3. Switch (Is language English?)
   • True → Skip to Step 4
   • False → HTTP Request (Translate to English)
4. HTTP Request (OpenAI: Draft Response)
5. HTTP Request (Immersive Translate AI: Back-Translate)
6. HTTP Request (ElevenLabs: Generate Audio)
7. HTTP Request (File Storage: Save Audio)
8. Switch (Route Based on Category)
9. Email / Slack (Notification)

In n8n, save the workflow and test with a sample webhook payload. The entire flow should complete in 15-30 seconds.

The Manual Alternative

If automation feels premature, or if you're working with highly sensitive cases that need human oversight throughout, you can use these tools with manual handoffs:

1. Receive a ticket in your support inbox.
2. Copy the message into ChatGPT Writer and request a draft response.
3. Use Immersive Translate AI's browser extension to translate the draft into the customer's language.
4. Play the audio in ElevenLabs to quality-check tone and accuracy.
5. Paste the final response into your support system.

This cuts the time per ticket from 10-15 minutes to 3-5 minutes whilst maintaining full editorial control. It's useful for onboarding; once your team is confident in the automated drafts, move to the full workflow.

Pro Tips

Error Handling and Retries. Language detection occasionally fails on very short messages or mixed-language input. Add a fallback to Zapier's built-in language detection or manually escalate to a human if confidence is below 80%. In n8n, use Try/Catch nodes to capture API errors and retry with exponential backoff.

Rate Limits. OpenAI allows 3,500 requests per minute on GPT-4o; ElevenLabs allows 100,000 characters per month on the starter plan. Monitor your usage and implement request queuing in n8n using a Rate Limit node. For high volume, consider upgrading plans or switching to a faster model like GPT-4o mini for routine tickets.

Cost Optimisation. ChatGPT Writer (via OpenAI API) costs roughly £0.01 per ticket. ElevenLabs audio generation is about £0.30 per 1,000 characters. Immersive Translate is free for non-commercial use or £5/month for commercial API access. If cost is a constraint, make audio generation optional; only generate audio for tickets marked as priority or urgent.

Hallucination Risks. GPT-4o occasionally generates plausible but incorrect information. Include a human review step for account-related, billing, or security issues. Use a Switch node to flag these categories and require approval before sending.

Multilingual Quality Assurance. Immersive Translate AI's translation quality varies by language pair. Test with real customer messages in each language you support before going live. Consider using a combination of translation services; Immersive Translate AI excels at European languages, while Google Translate might be more reliable for Asian languages.

Cost Breakdown

Total estimated cost for 500 tickets/month: £15–£50 depending on your choice of orchestration platform.

Once you've built this workflow, your support team spends time reviewing and personalising drafts rather than generating them from scratch. Response times drop from hours to minutes, multilingual tickets no longer create bottlenecks, and your team has clear visibility into which issues are routing where. Start small with 10-20 tickets, refine your prompts and routing rules based on real feedback, then scale.