top of page

How to Merge Tickets in Zendesk?

manual vs. automated

Discover automated and manual ways to manage duplicate customer tickets 

 

Dealing with duplicate tickets in Zendesk can quickly become overwhelming, especially when customer tickets flood in from various channels or are submitted repeatedly. Whether it’s due to agent errors or customers reporting the same issue multiple times, managing these duplicates is crucial to keeping your support queue organized and efficient.

 

In this guide, we'll walk you through how to merge tickets in Zendesk, covering both manual and automated methods. We'll also explore the advantages of consolidating tickets, showing how it reduces confusion, streamlines your workflow, and helps your team deliver a seamless customer experience. Let’s dive into the steps to optimize your ticket management.

Automatically Merge Zendesk Tickets So Your Team Doesn't Have to Do This Manually

Support Teams using automatic merging save up to 10% of their time allowing agents to focus on what matters most – delivering top-notch customer support.

banner

Why Do Duplicate Tickets Occur?

Duplicate tickets are a common challenge in customer support, and understanding their root causes is essential for effective ticket management. In this section, we'll explore a few typical scenarios that lead to duplicate tickets, including multiple requests from customers, channel-switching follow-ups, and third-party system interactions.

 

1. Customers Send Multiple Requests About the Same Issue

 

There are instances when customers might submit multiple requests regarding the same issue. They might be unsure if their initial request went through, wish to share additional details, or just can't wait for a response. As a result, multiple customer tickets for the same concern can pile up, leading to confusion and inefficiencies for the support agents handling the case.

Example of duplicate tickets created by the same customer in Zendesk

2. Customers Use Different Channels to Communicate​

Today's customers have numerous communication options, including email, live chat, social media, and phone calls. It's not uncommon for customers to switch between channels when seeking help, such as sending an initial email and then following up on live chat or phone call.

Even if your support team usually responds really quickly, something as simple as a ticket backlog from a busy week can spark questions and concerns among your customers, making them feel its necessary to reach out again before you have a chance to solve the original ticket.

When this happens, multiple Zendesk tickets can be created for the same issue, even though the customer really only has one issue or question that needs to be addressed.

3. Third-party systems create tickets on behalf of customers

 

Third-party systems have become essential tools to streamline customer interactions. For example, platforms like PayPal, Facebook, and other e-commerce systems can help businesses offer a seamless experience to their customers.

While these systems are a great asset, they can also cause some headaches for support teams.

One of the biggest challenges is the creation of duplicate tickets for the same issue.

This happens when these platforms use a generic email address, such as info@paypal.com, to create tickets on behalf of customers. Even though the ticket may include an identifier like a user ID or transaction number, the use of a shared email address can still lead to the creation of multiple tickets for the same issue.

Pro tip: You can use apps like Ticket Parser Autofill to automatically extract data from these tickets (like a user ID) and use it to auto-populate custom Zendesk ticket fields, speeding up your response time and making it easier to route tickets intelligently.

All in all, these scenarios highlight the importance of effectively managing duplicate tickets within Zendesk to ensure an efficient and professional customer support experience.

Why Duplicate Tickets Can Cause Problems

So, why are duplicate tickets a big deal?

 

Duplicate tickets can set off a chain reaction of challenges, affecting both the customer support team and the overall customer experience. Let's dive deeper into the potential pitfalls that may emerge from duplicate tickets.

1. Two Agents May Respond to Separate Tickets for the Same Customer

When customers submit multiple tickets for the same issue, it can lead to a situation where multiple agents are simultaneously working on the same problem. Moreover, with agents working on duplicate tickets, other customer inquiries can get neglected, leading to a poor experience and a less efficient support team.

Customer service agents working in the same time

2. Customers Receive Multiple Responses at Different Times

Duplicate tickets can be frustrating for customers and undermine their confidence in your support team. When customers receive multiple responses to the same issue from different agents, it can create confusion and reflect poorly on the company's professionalism. Receiving multiple responses can also be overwhelming and make it more difficult for customers to understand the resolution to their issue.

3. Inconsistency in Responses and Resolutions

Chances are, you're already using Zendesk macros to help your agents be more productive and stay on brand. However, macros can only go so far with duplicate tickets. For example, one agent may offer a refund, while another may suggest a different solution. This inconsistency can negatively impact customer satisfaction and potentially damage the company's reputation.

4. Increased Likelihood of Errors

When multiple agents work on separate tickets for the same issue, the chances of agent errors or providing incorrect information increase. These errors can further frustrate customers and prolong the resolution process.

5. Difficulty in Tracking Support Metrics

Duplicate tickets can mess with support metrics, making it difficult to precisely assess agent performance, response times, and resolution rates. This can lead to a skewed perception of the support team's effectiveness, ultimately hindering efforts to improve service quality.

By addressing the issue of duplicate tickets and implementing strategies to merge them, businesses can avoid these problems and ensure a more efficient, consistent, and professional customer support experience.
 

Merging Duplicate Tickets Manually in Zendesk

 

To merge tickets in Zendesk manually, simply follow the below steps, as detailed in the Zendesk support guide:

 

  • Navigate to your list of tickets in Zendesk and select the tickets you want to merge by clicking the checkbox next to each ticket.

  • Once you have selected the desired tickets, click the "Bulk Actions" button at the top of the ticket list.

  • In the "Bulk Actions" menu, click on "Merge tickets."

  • A window will appear, allowing you to review the tickets you're merging. You can choose which ticket to keep as the primary ticket by clicking the radio button next to it. The primary ticket will retain its ticket number, and all other tickets will be merged into it.

  • Click "Merge" to complete the process. The tickets will be merged, and all comments, tags, and other relevant information will be combined into the primary ticket.

Screenshot of merging two Zendesk tickets manually

Problems with Merging Tickets Manually

Although merging tickets manually is an effective way to address duplicate tickets, there are several drawbacks to this approach:

 

1. It's time-consuming

Manually merging tickets can eat up precious time, particularly when you have a lot of duplicates demanding attention. This steals valuable time that agents could otherwise dedicate to helping other customers.

2. It's prone to errors

With manual merging, there's always a risk that agents will make mistakes, such as merging the wrong tickets or failing to merge all relevant duplicates. These errors can prolong the resolution process and frustrate customers.

3. It creates customer frustration

When agents spend time manually merging tickets, customers may experience delays in receiving responses to their inquiries. Additionally, errors made during the merging process lead to further confusion and frustration for customers.

 

Given these drawbacks, many businesses are turning to automated solutions to streamline the process of merging duplicate tickets in Zendesk, which we will explore in the next section.

Merging Tickets in Bulk using the Zendesk API

 

While manual merging of duplicated tickets in Zendesk is an option, it can be time-consuming and error-prone.

To address these challenges, streamlining the process of merging duplicate tickets can offer a more reliable solution. In this section, we'll discuss a Python script that leverages the Zendesk API to merge tickets in bulk, reducing manual effort and minimizing errors.

Overview of the Bulk Solution

The provided Python script automates the merging process by:

1. Retrieving Open Tickets: Utilizing the Zendesk API’s search endpoint, the script fetches all open tickets. This helps identify potential duplicates that need merging.


2. Grouping Tickets by Requester: The script groups tickets based on the requester_id, identifying those submitted by the same customer.


3. Merging Process: For each group of tickets from the same requester, the script merges them into a single primary ticket. This ensures that all relevant information and communication history are consolidated, making it easier for support agents to manage and respond to customer inquiries.

Step-by-Step Walkthrough

1. Setup and Authentication

The script begins with setting up the necessary configurations, including the Zendesk domain, email, and API token. These credentials are essential for authenticating requests to the Zendesk API.​​

import requests
import json

# Set up your Zendesk credentials
email_address = 'your_email@example.com'
api_token = 'your_api_token'
subdomain = 'your_subdomain'

base_url = f'https://{subdomain}.zendesk.com/api/v2'

# Set up the headers with authentication
headers = {
    'Authorization': f'Basic {email_address}/token:{api_token}',
    'Content-Type': 'application/json'
}

​Here, the headers is used to create an authentication object that will be used in all API requests. This method ensures secure access to the Zendesk platform.

2. Retrieving Open Tickets

The script defines a function get_open_tickets() to fetch all new and open tickets from Zendesk. It uses the search endpoint with a query to filter tickets based on their status.

def get_all_open_tickets():
    url = f'{base_url}/search.json'
    params = {
        'query': 'type:ticket status:new status:open',
        'page': 1
    }
    tickets = []
    while True:
        response = requests.get(url, headers=headers, params=params)
        data = response.json()
        tickets.extend(data.get('results', []))
        
        # Check if there is a next page
        if data.get('next_page'):
            params['page'] += 1
        else:
            break
    return tickets

 

This function sends a sequence of GET requests to the Zendesk API, retrieving the list of all new and open tickets, page by page. It returns these tickets as a list of JSON objects.

3. Grouping Tickets by Requester

 

Next, the script organizes the retrieved tickets by requester_id. This grouping helps in identifying tickets that potentially belong to the same customer.

# Function to find tickets from the same requester
def group_tickets_by_requester(tickets):
    tickets_by_requester = {}
    for ticket in tickets:
        requester_id = ticket.get('requester_id')
        if requester_id:
            if requester_id not in tickets_by_requester:
                tickets_by_requester[requester_id] = []
            tickets_by_requester[requester_id].append(ticket['id'])
    return tickets_by_requester

In this segment, the script iterates through the list of open tickets and categorizes them based on the requester_id. The result is a dictionary where each key represents a requester, and the corresponding value is a list of ticket IDs associated with that requester.

4. Merging Tickets

 

The core functionality of the script is to merge tickets from the same requester. The merge_tickets() function handles this process.

def merge_tickets(target_ticket_id, ticket_ids_to_merge):
    url = f'{
base_url}/tickets/{target_ticket_id}/merge.json'
    data = {
        'ids': ticket_ids_to_merge,
        'source_comment': 'Merging tickets due to same requester',
        'target_comment': f'Combining with tickets {ticket_ids_to_merge}'
    }
    response = requests.post(url, headers=headers, data=json.dumps(data))
    return response.json()

This function sends a POST request to the Zendesk API, specifying the target ticket ID (the ticket that will retain all merged information) and the source ticket ID(s) (the tickets to be merged into the target ticket). The JSON payload contains the list of ticket IDs to merge and the merging comments.

 

5. Executing the Merging Process

 

Finally, the main section of the script iterates over the grouped tickets and merges them where necessary.

def main():
    # Step 1: Get all open tickets
    open_tickets = get_open_tickets()

    # Step 2: Group tickets by requester
    tickets_by_requester = group_tickets_by_requester(open_tickets)

    # Step 3: Merge tickets by requester
    for requester_id, ticket_ids in tickets_by_requester.items():
        if len(ticket_ids) > 1:
            # Choose the first ticket as the target and merge others into it
            target_ticket_id = ticket_ids[0]
            ticket_ids_to_merge = ticket_ids[1:]
            merge_response = merge_tickets(target_ticket_id, ticket_ids_to_merge)
            print(f'Merged tickets {ticket_ids_to_merge} into {target_ticket_id}: {merge_response}')

if __name__ == "__main__":
    main()

In this loop, the script checks if there are multiple tickets for the same requester. If so, it designates the first ticket as the primary and merges the subsequent tickets into it. The print statement provides a log of the merging activity.

The provided script for merging duplicate tickets in bulk offers a straightforward and efficient solution for consolidating customer issues in Zendesk. However, it does have limitations.

 

One significant drawback is that the merging process is not done in real-time, which means that unmerged tickets can sometimes slip through, allowing different agents to work on the same issue simultaneously. Additionally, the merging criteria used in the script are relatively simple, based solely on the same requester. Many companies require more complex criteria for merging tickets, such as matching multiple ticket fields, using text extraction from ticket comments, or applying different rules for specific subsets of tickets.

This often means to implement this approach, you need to understand Python or you'll need to pull in an engineer, which many support teams find difficult.

These challenges underscore the need for a more sophisticated and automated approach — on that provides real-time merging and the ability to apply more complex and flexible criteria.

Merging Duplicate Zendesk Tickets Automatically with A Trusted Zendesk App​​​

You can also merge tickets in Zendesk using a third-party app like Zendesk Merge Tickets, which is far and away the easiest and most foolproof solution to handling duplicate tickets.

Using an approved third-party app like this involves a one-time configuration (no Python knowledge necessary), after which it continuously checks for duplicates and merges them accordingly. Here's an overview of how this process works:

 

1. Configure the Automated System

Set up the automation rules, such as the merging window (i.e., the time frame within which tickets are considered duplicates) and the criteria used to identify duplicate tickets (e.g., email address, subject, etc.).

2. Continuous Duplicate Checking

Whenever a new ticket is created in the helpdesk, it is sent to the automated system for duplicate checking. If a duplicate is found based on the defined merging window and criteria, the tickets are merged into one.

 

3. Instant Merging

The automated merging process occurs almost instantly after a new ticket is created. As a result, agents will see the merged ticket before they even have a chance to work on the duplicate, ensuring they can focus on resolving the customer's issue efficiently.

 

By implementing an automated system for merging duplicate tickets, businesses can greatly improve their support team's efficiency, reduce the likelihood of errors, and enhance the overall customer experience.

5-Star Review of the Zendesk Merge Tickets App

How to Set Up Ticket Auto-Merging in Zendesk

 

To automate the process of merging duplicate tickets in Zendesk, you can use the Merge Duplicate Tickets app. The setup is straightforward and only takes a few minutes.

Configure the automatic merging of duplicate tickets in Zendesk

Follow these easy steps to enable automatic ticket merging:

 

1. Install the App and Register for a New Swifteq Account

Visit the Zendesk marketplace, find the Merge Duplicate Tickets app, and install it. After installation, register for a new Swifteq account or sign in with your existing credentials.

2. Define What you Consider to be a Duplicate Ticket

After setting up your account, you'll need to define your criteria for identifying duplicate tickets.

  • Merging window: Set a time frame within which tickets are considered duplicates. For example, if you set a 24-hour merging window, tickets created more than 24 hours apart won't be considered duplicates.

  • Merging criteria: Choose the ticket fields that must match for tickets to be considered duplicates. By default, tickets with the same email address are considered duplicates. However, you can add additional fields to be matched, such as Subject or Order Number.

  • Filters: Add filters to include or exclude tickets from merging

 

You can customize the merging process further by adding filters, triggers, and webhooks to include or exclude specific tickets. For example, you can exclude tickets based on the customer's email address or the Group to which the ticket was assigned. To add more filters, edit the conditions of the Zendesk trigger associated with the app.

And that's it! Once you've completed these steps, the Merge Duplicate Tickets app will automatically handle the merging process for you. This means your team won't have to merge tickets manually, saving time and reducing the risk of errors.

Merging Duplicate Tickets Is Vital for Your Customers and Team

Merging duplicate tickets manually can be a time-consuming and error-prone process, leading to various issues such as wasted agent time, customer confusion, and a negative impact on the company's professionalism.

 

In contrast, automating the merging process offers many benefits:

  • It saves time for support agents, allowing them to focus on assisting customers and resolving issues more efficiently.

  • It reduces the risk of errors in the merging process, ensuring that the correct tickets are merged and all relevant duplicates are addressed.

  • It provides a more consistent and faster response to customers, leading to increased satisfaction and a better reputation for your company.

 

When you use the Merge Duplicate Tickets app, you're able to permanently solve for duplicate Zendesk tickets, once and for all. It only takes a few minutes to set up and get started — and you can start your own 14-day free trial today to give it a test run!  

bottom of page