JS Support Ticket vs Awesome Support: A Helpdesk Plugin Comparison

April 2, 2018 | Competitive Analysis


Are you trying to make the decision between JS Support Ticket vs Awesome Support for your company's helpdesk solution?

Because there are so many little features that can affect your support team's productivity and workflows, choosing a WordPress helpdesk plugin can be a difficult decision.

At first glance, many plugin's feature lists look similar. But once you actually get your hands dirty and start using a plugin, you start to see the deeper functionality aspects that play a big role in how effectively you can support your customers.

To help you go beyond the marketing copy and make your decision, we created this in-depth, 3,000+ word comparison of JS Support Ticket vs Awesome Support.

By the time that you finish reading this post, we hope that you have a much deeper understanding of how each plugin functions. And, more importantly, we hope that you have the information that you need to confidently make your decision.

If you're considering other plugins, we'll also use the same format as our WP Support Plus vs Awesome Support comparison so that you can compare all three against one another.

Related: Eight WordPress Help-Desk Plugins Reviewed

JS Support Ticket vs Awesome Support: An Overview

JS Support Ticket operates on a freemium billing model. That is, it has a free version that's available at WordPress.org, as well as a single premium version that offers various pricing plans.

According to its WordPress.org page, JS Support Ticket is active on 3,000+ installations and has a 4.1-star rating on 36 reviews.

Awesome Support, on the other hand, is a free core plugin that you can add functionality to with multiple premium extensions. Because it's extension-based, you can pick and choose the exact features that you want to pay for, rather than purchasing everything at once.

According to its WordPress.org page, Awesome Support is active on 7,000+ installations and has a 4.6-star rating on 106 reviews.

By the end of this article, you should have all the knowledge that you need to choose between these two helpdesk plugins.

Note - we're going to look at each plugin as if you had all the premium features. Many of the deeper features here are not available in the free versions of either plugin.

Ticket Creation Process - Methods, Custom Fields + More

This section will compare the two plugins on functionality like:

  • The different methods available to customers to create support tickets
  • How much control you have over the data that you collect from customers (e.g. custom fields, custom forms, etc.)

JS Support Ticket

As with most helpdesk plugins, JS Support Tickets gives you and your customers three different ways to create new support tickets:

  • Frontend ticket creation forms
  • Automatic email imports
  • Manual ticket creation via the backend (this is only for support agents)

Out of the box, JS Support Ticket's frontend forms include fields for:

  • Priority
  • Name
  • Phone
  • Email
  • Department
  • Help Topic
  • Subject
  • Attachment
  • Issue Summary

And if you want to add additional fields, you can add custom fields for:

  • Text
  • Checkbox
  • Date
  • Drop down
  • Email address
  • Radio button
  • File attachment
  • Multi-select

Two nice things here are that you can:

  • Choose whether or not to allow anonymous users to create tickets
  • Choose whether to keep each field public or save it for internal use

Awesome Support

Awesome Support gives you the same three core methods of ticket creation:

  • Front-end submission forms
  • Email piping
  • Manual ticket creation via the WordPress back-end (wp-admin)

But it also supports two additional methods that give you some added flexibility:

  • Gravity Forms - this lets you design your own ticket forms via the Gravity Forms interface, including conditional fields.
  • Direct REST API - this gives you a ton of flexibility by allowing you to connect to other services - most notably, Zapier.

Like JS Support Ticket, you can choose whether or not to allow anonymous users to create a ticket.

Out of the box, it provides the following fields pre-configured for your front-end ticket forms:

  • Help Topic / Subject
  • Description
  • Priority (optional)
  • Product (optional)
  • Department (optional)
  • Attachment (optional)
  • Email

During the user registration process you can collect:

  • First Name
  • Last Name
  • Terms and Conditions acknowledgement
  • Up to three GDPR/Privacy related acknowledgement items

And on the back-end it provides the following fields to allow agents to manage the tickets:

  • Status
  • Channel
  • Time tracking
  • Primary, Secondary and Tertiary Agents

If you want to customize the core front-end submission forms, you can choose from 11 different types of custom fields, including fields like taxonomies and account passwords.  The taxonomy fields are especially useful since you can use them to allow the user to select from a pre-configured list such as a list of help topics, colors, serial numbers, sizes, shipping locations, container types etc.

For each field, you can configure:

  • Permissions
  • Defaults
  • Validation rules
  • Whether the field is required
  • Whether changes to a field should be logged in the ticket
  • Whether the field should show up on the front-end for the user to see or just for the agent
  • CSS classes and ids
  • Many more options (there are more than 25 options for each custom field you create)

One of the cooler things I found out while writing this review is that most of the default ticket form fields are actually just Awesome Support custom fields.  So you can, for example, turn off the default existing PRODUCT field and create your own custom PRODUCT field if you like!  I'm not sure that I've encountered another WordPress helpdesk plugin that has built itself up in tiers that way so that the same features can be used both internally and by customers and users.

Ticket Organization Options, Including Agent Assignment

After your customers create their tickets, you need a way to organize those tickets and assign them to the right agent. To that end, this section will compare how each plugin lets you:

  • Assign tickets to agents
  • Organize and categorize your tickets to work more efficiently

JS Support Ticket

Unfortunately, JS Support Ticket doesn't offer much in the way of intelligent ticket assignment when it comes to individual agents.

When a new ticket comes in, the plugin assigns it to the relevant department. But if you want to assign the ticket to a specific agent, you'll need to do that manually.

Small teams of 1-2 support agents might not mind this, but this functionality won't work nearly as well for a busier helpdesk.

When it comes to actual organization, JS Support Ticket is a mixed bag. On one hand, there's no way to display custom fields on the overall ticket listing page, which doesn't give you the option to customize that interface.

But what you can do is configure your own custom ticket statuses, complete with color coding:

JS Support Ticket also gives you plenty of functionality for filtering tickets.

The main disappointment here, though, is the lack of an intelligent way to assign incoming tickets to specific support agents.

Awesome Support

Whereas JS Support Ticket only lets you assign tickets to a department based on their category, Awesome Support gives you six different methods that you can use to control how tickets are assigned to agents.

These ticket assignment algorithms let you build a ticket assignment process that's truly unique to your business. For example, you can factor in information like:

  • How many tickets each individual agent already has assigned
  • Whether or not an agent is on-duty
  • Whether the agent is part of a specific product team or department

You can also mix-and-match these criteria using tons of conditions:

For example, you could create a process like:

  • First, check if there's an agent that supports the product and is actively working
  • Or, if none of those agents exist, assign the ticket to any other agent that's actively working

You can even let certain VIP clients pick their preferred support agent, among other assignment options.

Organizing Tickets in Awesome Support

Once those tickets are assigned, Awesome Support gives you multiple ways to filter tickets:

  • Ticket age and activity
  • Priority (if enabled)
  • Agent
  • Tags
  • Products
  • Channels (the location where the request came from – e.g. Email)

Unlike JS Support Ticket, you can also take any custom field that you added and make it:

  • Filterable
  • Sortable
  • Display as a column in your screen

Individual agents can also create their own reusable custom filters to quickly find certain types of tickets:

You also get four different options for color-coding your tickets. You can add colors for:

  • Status
  • Priority
  • Age
  • Overdue Flags

Finally, individual agents get another organization feature in the form of custom to-do lists:

Working With Individual Tickets - Responses, Transfers + More

In this section, you'll learn the options that each plugin offers for letting you actually respond to tickets from the interface. Beyond responding directly to customers, we'll also compare how each plugin lets you:

  • Add internal notes
  • Transfer tickets to other agents
  • View ticket histories so that you know what's been done
  • Other ticket manipulations (like splitting or combining tickets)

While both plugins also let you respond to tickets via email, we're going to save a more detailed discussion of that functionality for the next comparison section.

JS Support Ticket

When you respond to tickets from the internal JS Support Ticket interface, you have a solid degree of flexibility.

For each ticket that you work with, you can:

  • Write a standard reply
  • Add an internal note
  • Transfer to a different department
  • Assign to a different staff member
  • Change the ticket’s status
  • Edit the ticket’s basic details
  • Lock the ticket
  • Close the ticket permanently

You also get some helpful productivity tools that let you:

  • Use pre-made canned responses (though you're unable to dynamically insert any information in these)
  • Append a custom signature for the individual support agent or the entire department
  • Automatically close a ticket if the customer hasn't responded in a certain number of days

Awesome Support

While JS Support Ticket does give you solid functionality here, Awesome Support offers all of the same features, plus additional features and tweaks to make things more helpful.

For each ticket, Awesome Support lets you:

  • Change the ticket status, product, department, etc.
  • Insert a canned response
  • Insert FAQ or documentation links
  • Transfer the ticket to another agent
  • Attach files
  • Add an internal note

Here are some examples of how Awesome Support takes those features further, though.

While both plugins let you insert canned replies, Awesome Support lets you use template tags to dynamically insert information in these canned replies.

For example, you can address your customer by their actual name using a template tag, and you can also provide customized information about their ticket's status...all using the same canned reply.

In total, you have more than 12 different template tags that you can use in your canned responses.

As another example, while both plugins let you add internal notes and transfer tickets, Awesome Support lets you perform both actions at the same time for a more efficient workflow between multiple support agents:

Another helpful feature for working with tickets is the option to split a ticket into separate tickets or, alternatively, to merge multiple tickets into a single ticket.

And finally, Awesome Support lets you automatically close tickets based on inactivity just like JS Support Ticket. But, you can take this functionality even further and send out a series of reminder emails to your customer before you actually close the ticket.  Better still, you can send out a series of reminders based on the custom status of the ticket.  So a ticket that was escalated can have a completely different closing sequence of emails than one that was handled normally.

Email Piping And Notifications Options

Email piping is a powerful tool that lets you and your customers work outside the actual helpdesk interface. In this section, we'll compare how each plugin performs when it comes to:

  • Importing emails as tickets
  • Responding to tickets via email (for both customers and agents)
  • Ticket Management via email

JS Support Ticket

JS Support Ticket gives you a couple different ways to work with email. You can:

  • Create new tickets from emails that your customers send
  • Reply to tickets via email, instead of needing to use the web interface

You also get some deeper functionality that lets you:

  • Ban specific email addresses if you're having issues with spam
  • Import email attachments as ticket attachments in your dashboard
  • Choose whether or not your customers can reply to a closed ticket via email

While those deeper features are nice, you'll also encounter two potential limitations:

  • You can only import tickets from a single mailbox.  This is limiting if you use different support email addresses (e.g. a pre-sales support email vs a technical support email)
  • There's no way to handle the situation where a user replies from a different email address than they originally used

As for email notifications, you can enable/disable individual emails for specific user roles:

And you can also customize the text of each email, including inserting some merge tags for dynamic information:

The only disappointing thing here is that you can only control emails for the three roles of admin, staff, and user.

Awesome Support

Like JS Support Ticket, Awesome Support lets you:

  • Import emails as new tickets
  • Respond to tickets via email

But Awesome Support also gives you a third option for working with email - your agents can close or transfer tickets via email.

It also gives you deeper functionality for how you import tickets. You can import tickets from multiple email mailboxes. Depending on the email address, you can then assign specific:

  • Priorities
  • Channels
  • Products
  • Departments

You can also choose what happens:

  • If a user doesn't already have an account at your site
  • If a user is responding to a closed ticket

To help you manage your email tickets, you can create your own filters and rules. These are what give you the ability to perform actions like:

  • Closing a ticket via email
  • Transferring a ticket via email
  • Assigning a specific agent based on keywords in the email
  • Filtering undesirable language

As for notification emails, Awesome Support gives you 6  core default notification emails that you can customize as needed plus many additional ones depending on which premium add-ons you've enabled. The six core default emails are:

  • Submission Confirmations
  • New Assignments to Agents
  • New Reply From Agent
  • New Reply From Client
  • Ticket Closed By Agent
  • Ticket Closed By Client

Beyond those emails, you can create your own emails for each custom status that you add.  For example, if you create a custom label/status called ESCALATE then you will also be able to create an email alert whenever a ticket is changed to the ESCALATE status.

You're not just limited to email, either. You can also set up notifications for users or agents via Slack, Pushbullet, SMS (via Twilio) or any other service supported by Zapier.

And you also have the option to set up alerts for third-parties that aren't a direct part of the ticket, which is helpful when you support organizations with multiple key stakeholders.  Small business owners, department supervisors, support auditors etc. can all be kept in the loop even if they're not directly related to a ticket.

Additionally, there are some processes where you can set up email sequence - for example, when automatically closing a ticket for inactivity you can set up a series of email warning messages before the ticket is actually closed.

Finally, many premium add-on adds its own set of email notifications.  For example, you can have email notifications for:

  • Ticket Merged and Closed
  • Ticket Merged and Reply Added
  • Email Reply Rejected
  • Unassigned Ticket Created
  • Email Reply Rejected Because Of Ticket Lock

Security Functionality For Sensitive Data

If you'll need to handle sensitive data as part of your support efforts, like usernames and passwords, you'll need a way to securely store that data while your agents work. In this section, we'll compare the options that each plugin gives you for doing that.

JS Support Ticket

JS Support Ticket lacks any dedicated functionality to handle sensitive data. The only option as user has is to add such data as a regular ticket response (or send the information outside the ticket channel).

Awesome Support

Awesome Support offers a built-in private credentials vault for sensitive data. This vault:

  • Has special encryption
  • Automatically deletes its data when the ticket is closed so that you don't permanently store any sensitive data on your server

You can also further control who has access to certain information with Awesome Support's 30+ WordPress capabilities, as well as its four default user roles. You can even create your own roles with custom capabilities using a free plugin like User Role Editor.

And you can also create something called Security Profiles that let you control exactly which tickets certain agents can see:

Reporting And Data Functionality

Reports help you see how your helpdesk and agents are performing. And, with the right data, your reports can also give you actionable insights to improve your support efforts.

In this section, we'll compare the data that each plugin gives you access to.

JS Support Ticket

With JS Support Ticket, you get a dashboard with a look at overall stats for your helpdesk:

And you can also drill-down into more specific reports for:

  • Staff members
  • Departments
  • Users

Awesome Support

At a high-level, Awesome Support gives you a variety of dashboard widgets that you can use to view stats by:

  • Agent
  • Channel
  • Status
  • Priority
  • Department
  • Etc.

Because these widgets use the core WordPress functionality, you can add, remove, and rearrange them using the built-in WordPress controls. This allows you to create a customized dashboard that's unique to your specific needs:

Beyond these dashboard widgets, Awesome Support also includes an area with more advanced reports and statistics. This area offers 6 core report types that help you dig deeper into your helpdesk's performance:

  • Ticket counts – the number of tickets by status
  • Productivity analysis – the average, median, and maximum number of replies needed to close a ticket
  • Resolution analysis – the average and median time (in minutes) it takes to close a ticket
  • Delay analysis – the average time it takes to respond to a ticket
  • Distribution analysis – the number of tickets that contain 1, 2, 3,…N number of replies
  • Trend analysis – the number of tickets opened/closed over a certain period

For example, the distribution analysis breaks up tickets not just by the number of replies, but also by their status:

For each of these 6 core reports, you can also use filtering options to dig even deeper. And you can also save a report (including its filters) to quickly bring it up at a later date. You can even use security controls to limit which users can view certain reports.

Other Smaller, But Relevant, Features

In this section, we'll compare features that don't warrant their own section but are nonetheless still important to creating a well-functioning helpdesk.

JS Support Ticket

JS Support Ticket doesn't stray too far from the core functionality outlined above. But its premium version does include support for:

  • Documentation
  • Support forums

For example, here's how the documentation area looks:

JS Support Ticket also offers time tracking for agents (which you saw in the ticket reply interface above).

Awesome Support

Through Awesome Support's various add-ons, you can get:

  • Time Tracking - including an option for handling billable hours.
  • eCommerce support - integrations for WooCommerce, Easy Digital Downloads, and Envato ( Awesome Support is the only helpdesk plugin that supports all three major e-commerce vendors in the WordPress space.)
  • Service Level Agreements - specialized functions that allow you to create and track due dates that take into account weekends, holidays, work hours and more.
  • Ticket Limits - limit the number of tickets per user (if needed).
  • Satisfaction Surveys - send 4 different types of surveys to gather qualitative and quantitative data.
  • FAQs And Documentation - create FAQs and documentation pages to prevent support requests in the first place.
  • Smart Replies - use smart searches and A.I. technologies to provide automated replies via email, Facebook chatbots, or your own website chat.
  • Public Tickets - create a searchable archive of tickets as a self-help option.
  • Issue Tracking - easily manage multiple tickets that are caused by the same or similar issue


JS Support Ticket

JS Support Ticket has a free version available at WordPress.org.

The Pro version starts at $59 for a single site license, though you only get one priority support ticket (rather than unlimited priority support during the duration of your license).

Awesome Support

The core Awesome Support plugin is free and available at WordPress.org.

If you need more functionality, you can extend your helpdesk with:

  • Individual add-ons - these range from ~$19 to $49 each.
  • Bundles - these contain collections of add-ons grouped together for specific use cases.

Currently, Awesome Support offers 4 different bundles - you can view the specific add-ons in each bundle here:

  • Standard – $149
  • Pro – $229
  • Enterprise – $289
  • Agency – $409

Final Thoughts On JS Support Ticket vs Awesome Support

For a more quantitative look at JS Support Ticket vs Awesome Support, we've rated important areas on a scale from 1-3. For this scale:

  • 1 = below average depth of functionality. An overall score of 11-21 means below average functionality.
  • 2 = average depth of functionality. An overall score of 22 means average functionality.
  • 3 = above average depth of functionality. An overall score of 23-33 means above average functionality.
JS Support Tickets Awesome Support
Overall Depth 20 30
Minimum Start-up Cost Free Free
Ticket Creation 2 2
Custom Forms 1 3
Custom Fields 2 3
Ticket Organization 2 3
Agent Assignment 2 3
Ticket Response Interface 3 3
Email Piping 2 3
Email Notifications 2 3
Added Security 1 3
Stats and Data 2 3
Company Profiles 1 1
Overall Depth 20 30

Overall, JS Support Ticket sits a tiny bit below average, while Awesome Support offers deeper functionality in a number of important areas like:

  • How you work with tickets over email
  • Productivity tools and interface design to help your agents work more effectively
  • How tickets are actually assigned to agents
  • Smaller niche features like service level agreements, third-party notifications, and more

If you're interested in trying these deeper features, you can use the fully-featured Awesome Support demo to experience things for yourself.

About The Author: Colin Newcomer

Colin Newcomer has been working with WordPress for over 11 years. Since September 2016, he's been working full-time as a freelance writer focusing primarily on WordPress and digital marketing. He helps clients grow their web visibility by writing engaging, well-researched blog posts. You can contact Colin through his website at: https://www.cnewcomer.com/


Purchase A Bundle

Download Free Plugin

Install From WordPress.org