Celery just released their API on Github, currently in beta. Here are some of the cool stuff you can do with it in Gorgias.

‍

Display customer information

When you receive an email from a customer, you can connect your Celery account and see customer information (orders, shipping address, etc.). Here’s what it looks like:

‍

To configure it, grab your Celery access_token, head to integrations, and add an HTTP integration using this URL:
https://api.trycelery.com/v2/orders?buyer.email={ticket.requester.email}

‍

Then you can customize the sidebar to only show the Celery data you need to respond to customers. Click the cog and simply drag and drop elements you want to show.

‍

Refunds, order change... without leaving tickets

Celery’s API enables you to perform a few actions from your favorite helpdesk:

• Edit an order
• Cancel an order
• Issue a refund
• Create a coupon

‍

Here’s an example of how you can cancel an order from Gorgias itself. Say you already have a macro to cancel an order. Add an HTTP action to it, in this case:
https://api.trycelery.com/v2/orders/{ticket.requester.customer.data[0].number}/order_cancel

‍

Then, when you use this macro and send it to the customer, it will automatically cancel the last order at the same time:

‍

We hope this integration with Celery can save you time. If you'd like to try Celery with Gorgias, shoot us a note! At support@gorgias.com.

TLDR: https://github.com/xarg/pghoard-k8s

‍

This is a small tutorial on how to do incremental backups using pghoard for your PostgreSQL (I assume you’re running everything in Kubernetes). This is intended to help people to get started faster and not waste time finding the right dependencies, etc..

‍

pghoard is a PostgreSQL backup daemon that incrementally backups your files on a object storage (S3, Google Cloud Storage, etc..).
For this tutorial what we’re trying to achieve is to upload our PostgreSQL to S3.

‍

First, let’s create our docker image (we’re using the alpine:3.4 image cause it’s small):

FROM alpine:3.4

ENV REPLICA_USER "replica"
ENV REPLICA_PASSWORD "replica"

RUN apk add --no-cache \
   bash \
   build-base \        
   python3 \
   python3-dev \
   ca-certificates \
   postgresql \
   postgresql-dev \
   libffi-dev \
   snappy-dev
RUN python3 -m ensurepip && \
   rm -r /usr/lib/python*/ensurepip && \
   pip3 install --upgrade pip setuptools && \
   rm -r /root/.cache && \
   pip3 install boto pghoard


COPY pghoard.json /pghoard.json.template
COPY pghoard.sh /

CMD /pghoard.sh

‍

‍

REPLICA_USER and REPLICA_PASSWORD env vars will be replaced later in your Kubernetes conf by whatever your config is in production, I use those values to test locally using docker-compose.

‍

The config pghoard.json which tells where to get your data from and where to upload it and how:

‍

{
   "backup_location": "/data",
   "backup_sites": {
       "default": {
           "active_backup_mode": "pg_receivexlog",
           "basebackup_count": 2,
           "basebackup_interval_hours": 24,
           "nodes": [
               {
                   "host": "YOUR-PG-HOST",
                   "port": 5432,
                   "user": "replica",
                   "password": "replica",
                   "application_name": "pghoard"
               }
           ],
           "object_storage": {
               "aws_access_key_id": "REPLACE",
               "aws_secret_access_key": "REPLACE",
               "bucket_name": "REPLACE",
               "region": "us-east-1",
               "storage_type": "s3"
           },
           "pg_bin_directory": "/usr/bin"
       }
   },
   "http_address": "127.0.0.1",
   "http_port": 16000,
   "log_level": "INFO",
   "syslog": false,
   "syslog_address": "/dev/log",
   "syslog_facility": "local2"
}

‍

Obviously replace the values above with your own. And read pghoard docs for more config explanation.

‍

Note: Make sure you have enough space in your /data; use a Google Persistent Volume if you DB is very big.

‍

Launch script which does 2 things:

1. Replaces our ENV variables with the right username and password for our replication (make sure you have enough connections for your replica user)
2. Launches the pghoard daemon.

‍

‍

#!/usr/bin/env bash

set -e

if [ -n "$TESTING" ]; then
   echo "Not running backup when testing"
   exit 0
fi

cat /pghoard.json.template | sed "s/\"password\": \"replica\"/\"password\": \"${REPLICA_PASSWORD}\"/" | sed "s/\"user\": \"replica\"/\"password\": \"${REPLICA_USER}\"/" > /pghoard.json
pghoard --config /pghoard.json

‍

Once you build and upload your image to gcr.io you’ll need a replication controller to start your pghoard daemon pod:

‍

apiVersion: v1
kind: ReplicationController
metadata:
 name: pghoard
spec:
 replicas: 1
 selector:
   app: pghoard
 template:
   metadata:
     labels:
       app: pghoard
   spec:
       containers:
       - name: pghoard
         env:
           - name: REPLICA_USER
             value: "replicant"
           - name: REPLICA_PASSWORD
             value: "The tortoise lays on its back, its belly baking in the hot sun, beating its legs trying to turn itself over. But it can't. Not with out your help. But you're not helping."
         image: gcr.io/your-project/pghoard:latest

‍

The reason I use a replication controller is because I want the pod to restart if it fails, if a simple pod is used it will stay dead and you’ll not have backups.

‍

Future to do:

• Monitoring (are you backups actually done? if not, do you receive a notification?)
• Stats collection.
• Encryption of backups locally and then uploaded to the cloud (this is supported by pghoard).

Hope it helps, stay safe and sleep well at night.

‍

Again, repo with the above: https://github.com/xarg/pghoard-k8s

At Gorgias we recently switched our flask & celery apps from Google Cloud VMs provisioned with Fabric to using docker with kubernetes (k8s). This is a post about our experience doing this.

‍

Note: I'm assuming that you're somewhat familiar with Docker.

‍

Docker structure

The killer feature of Docker for us is that it allows us to make layered binary images of our app. What this means is that you can start with a minimal base image, then make a python image on top of that, then an app image on top of the python one, etc..

‍

Here's the hierarchy of our docker images:

• gorgias/base - we're using phusion/baseimage as a starting base image.
• gorgias/pgbouncer
• gorgias/rabbitmq
• gorgias/nginx - extends gorgias/base and installs NGINX
• gorgias/python - Installs pip, python3.5 - yes, using it in production.
• gorgias/app - This installs all the system dependencies: libpq, libxml, etc.. and then does pip install -r requirements.txt
• gorgias/web - this sets up uWSGI and runs our flask app
• gorgias/worker - Celery worker

‍

Piece of advice: If you used to run your app using supervisord before I would advise to avoid the temptation to do the same with docker, just let your container crash and let k8s handle it.

‍

Now we can run the above images using: docker-compose, docker-swarm, k8s, Mesos, etc...

‍

We chose Kubernetes too

There is an excellent post about the differences between container deployments which also settles for k8s.

‍

I'll also just assume that you already did your homework and you plan to use k8s. But just to put more data out there:

‍

Main reason: We are using Google Cloud already and it provides a ready to use Kubernetes cluster on their cloud.

‍

This is huge as we don't have to manage the k8s cluster and can focus on deploying our apps to production instead.

‍

Let's begin by making a list of what we need to run our app in production:

• Database (Postgres)
• Message queue (RabbitMQ)
• App servers (uWSGI running Flask)
• Web servers (NGINX proxies uWSGI and serves static files)
• Workers (celery)

‍

Why Kubernetes again?

We ran the above in a normal VM environment, why would we need k8s? To understand this, let's dig a bit into what k8s offers:

• A pod is a group of containers (docker, rtk, lxc...) that runs on a Node. It's a group because sometimes you want to run a few containers next to each other. For example we are running uWSGI and NGINX on the same pod (on the same VM and they share the same ip, ports, etc..).
• A Node is a machine (VM or metal) that runs a k8s daemon (minion) that runs the Pods.
• The nodes are managed by the k8s master (which in our case is managed by the container engine from Google).
• Replication Controller or for short rc tells k8s how many pods of a certain type to run. Note that you don't tell k8s where to run them, it's master's job to schedule them. They are also used to do rolling updates, and autoscaling. Pure awesome.
• Services take the exposed ports of your Pods and publishes them (usually to the Public). Now what's cool about a service that it can load-balance the connections to your pods, so you don't need to manage your HAProxy or NGINX. It uses labels to figure out what pods to include in it's pool.
• Labels: The CSS selectors of k8s - use them everywhere!
• ‍

There are more concepts like volumes, claims, secrets, but let's not worry about them for now.

‍

Postgres

We're using Postgres as our main storage and we are not running it using Kubernetes.

‍

Now we are running postgres in k8s (1 hot standby + pghoard), you can ignore the rest of this paragaph.

The reason here is that we wanted to run Postgres using provisioned SSD + high memory instances. We could have created a cluster just for postgres with these types of machines, but it seemed like an overkill.

The philosophy of k8s is that you should design your cluster with the thought that pods/nodes of your cluster are just gonna die randomly. I haven't figured our how to setup Postgres with this constraint in mind. So we're just running it replicated with a hot-standby and doing backups with wall-e for now. If you want to try it with k8s there is a guide here. And make sure you tell us about it.

‍

RabbitMQ

RabbitMQ (used as message broker for Celery) is running on k8s as it's easier (than Postgres) to make a cluster. Not gonna dive into the details. It's using a replication controller to run 3 pods containing rabbitmq instances. This guide helped: https://www.rabbitmq.com/clustering.html

‍

uWSGI & NGINX

As I mentioned before, we're using a replication controller to run 3 pods, each containing uWSGI & NGINX containers duo: gorgias/web & gorgias/nginx. Here's our replication controller web-rc.yaml config:

‍

apiVersion: v1
kind: ReplicationController
metadata:
 name: web
spec:
 replicas: 3 # how many copies of the template below we need to run
 selector:
   app: web
 template:
   metadata:
     labels:
       app: web
   spec:
     containers:
     - name: web
       image: gcr.io/your-project/web:latest # the image that you pushed to Google Container Registry using gcloud docker push
       ports: # these are the exposed ports of your Pods that are later used by the k8s Service
         - containerPort: 3033
           name: "uwsgi"
         - containerPort: 9099
           name: "stats"
     - name: nginx
       image: gcr.io/your-project/nginx:latest
       ports:
         - containerPort: 8000
           name: "http"
         - containerPort: 4430
           name: "https"
       volumeMounts: # this holds our SSL keys to be used with nginx. I haven't found a way to use the http load balancer of google with k8s.  
         - name: "secrets"
           mountPath: "/path/to/secrets"
           readOnly: true
     volumes:
       - name: "secrets"
         secret:
           secretName: "ssl-secret"
And now the web-service.yaml:apiVersion: v1
kind: Service
metadata:
 name: web
spec:
 ports:
 - port: 80
   targetPort: 8000
   name: "http"
   protocol: TCP
 - port: 443
   targetPort: 4430
   name: "https"
   protocol: TCP
 selector:
   app: web
 type: LoadBalancer

‍

That type: LoadBalancer at the end is super important because it tells k8s to request a public IP and route the network to the Pods with the selector=app:web.
If you're doing a rolling-update or just restarting your pods, you don't have to change the service. It will look for pods matching those labels.

‍

Celery

Also a replication controller that runs 4 pods containing a single container: gorgias/worker, but doesn't need a service as it only consumes stuff. Here's our worker-rc.yaml:

‍

apiVersion: v1
kind: ReplicationController
metadata:
 name: worker
spec:
 replicas: 2
 selector:
   app: worker
 template:
   metadata:
     labels:
       app: worker
   spec:
     containers:
     - name: worker
       image: gcr.io/your-project/worker:latest

‍

‍

Some tips

• Installing some python deps take a long time, for stuff like numpy, scipy, etc.. try to install them in your namespace/app container using pip and then do another pip install in the container that extends it, ex: namespace/web, this way you don't have to rebuild all the deps every time you update one package or just update your app.
• Spend some time playing with gcloud and kubectl. This will be the fastest way to learn of google cloud and k8s.
• Base image choice is important. I tried phusion/baseimage and ubuntu/core. Settled for phusion/baseimage because it seems to handle the init part better than ubuntu core. They still feel too heavy. phusion/baseimage is 188MB.

‍

‍

Conclusion

With Kubernetes, docker finally started to make sense to me. It's great because it provides great tools out of the box for doing web app deployment. Replication controllers, Services (with LoadBalancer included), Persistent Volumes, internal DNS. It should have all you need to make a resilient web app fast.

At Gorgias we're building a next generation helpdesk that allows responding 2x faster to common customer requests and having a fast and reliable infrastructure is crucial to achieve our goals.

If you're interested in working with this kind of stuff (especially to improve it): we're hiring!

We've released a new version of the Chrome Extension, with sharing features and a new navigation bar. We hope you'll love it!

‍

Share templates inside the extension

Before, the only way to share templates with your teammates was to login on Gorgias.io.

If you're on the startup plan, when you create a template, you can choose who has access to it: either only you, specific people, or your entire team.

‍

‍

The account management section is now available in the extension, under settings.

‍

New navigation

Tags are now available on the left. It's easier to manage hundreds of templates with them.
You can also navigate through your private & shared templates. Shared templates include templates shared with specific people or with everyone.

‍

‍

We hope you'll enjoy this new version of our Chrome Extension. As usual, your feedback & questions are welcome!

Today, we’re thrilled to announce that we’ve raised a $1.5 million Seed round led by Charles River Ventures and Amplify Partners, to help build our new helpdesk.

‍

We’re incredibly grateful to early users, customers, mentors we’ve met both at and Techstars.

‍

We started the journey with Alex at the beginning of 2015 with our Chrome extension, which helps write email faster using templates. We’ve been pleased all along with customers telling us about how helpful it was, especially for customer support.

‍

While building the extension, we’ve realized that a big inefficiency in support lies in the lack of integration between the helpdesk, the payment system, CRM and other tools support is using. As a result, agents need to do a lot of repetitive work to respond to customer requests, especially when the company is big.

‍

That’s why we’ve decided to build a new kind of helpdesk to enable customer support agents to respond 2x faster to customers. You can find out more and sign up for our private beta here.

‍

When a company has a lot of customers, support becomes repetitive. We want to provide support teams with tools to automate the way they treat simple repetitive requests. This way, they have more time for complex customer issues.

‍

We'll now focus on this helpdesk and on growing the team, oh, and if you'd like to join, we're hiring! We're super excited about this new helpdesk product. If you’re using the extension, don’t worry.

‍

Romain & Alex

We've been busy, but not deaf!

Last few months we got lots of feedback about our extension and found to our delight that most people are satisfied, but still a few recurrent issues came up:

• The HTML/WYSIWYG editor sucks.
• No support for Outlook.com.

‍

We listened and now we're presenting:

• A brand new editor
• Support for outlook.com
• More on the Rich-Text editor

‍

WYSIWYG editors for the web are notoriously buggy and are just difficult to develop.

‍

I have yet to see one that is bug free. There are few venerable editors that do a good job like TinyMCE, FKEditor or CKEditor.. but they are big and all have edge cases that break the intended formatting and add a lot of garbage html.

‍

There are newer good quality editors in town such as Redactor. The one that got my attention and finally landed in Gorgias is this wonderful editor called which is super lightweight, uses modern content-editable (no i-frames) and 'just works' most of the time. That's not to say it's perfect, but it's good enough and I'm satisfied with it's direction in terms of development.

‍

Enjoy it and as always send us bug-reports or feedback on: support@gorgias.com

TL;DR:

• A CX helpdesk centralizes customer conversations across email, chat, SMS, and social into one unified inbox
• Modern CX helpdesks combine support ticket management with revenue-driving features like personalized recommendations and automated order management
• The best platforms for ecommerce integrate deeply with Shopify and other commerce tools to enable self-service order tracking, returns, and account management
• Leading solutions like Gorgias, Zendesk, and Freshdesk now include AI agents that can resolve up to 60% of inquiries automatically
• Choose based on your ecommerce stack, team size, and whether you need specialized features for conversion optimization versus general support

A CX helpdesk is the command center where ecommerce brands manage every customer conversation, from pre-purchase questions to post-purchase support.

Unlike traditional IT helpdesks that focus on internal tickets, CX helpdesks are built for customer-facing teams who need to resolve issues fast while driving sales. Modern platforms combine ticket management with AI automation, letting you handle support at scale without sacrificing quality.

For ecommerce brands specifically, the right CX helpdesk turns support from a cost center into a revenue driver by enabling agents to recommend products, process returns, and recover abandoned carts — all from one screen.

What is a CX helpdesk?

A customer experience (CX) helpdesk is a software platform that unifies all customer conversations from every channel into a single, shared inbox. This means emails, live chat messages, social media comments, and SMS texts all land in one place, giving your support team a complete view of every customer interaction.

CX stands for customer experience, which is the entirety of a customer's interaction with your brand. This includes everything from browsing your website to receiving their order and getting help when they need it. A CX helpdesk focuses specifically on managing these conversations to create positive experiences that keep customers coming back.

Unlike a generic helpdesk built for IT or B2B companies, a CX helpdesk for ecommerce is designed around the shopper. It integrates directly with your store backend, like Shopify, to pull in crucial data like order history, shipping status, and past purchases. This allows agents to resolve issues without switching tabs, turning a simple question into a fast, personalized experience.

The core of any CX helpdesk is its ticketing system. A ticketing system is a tool that organizes each customer inquiry into a trackable ticket with a unique ID, status, and history. From there, automation and AI can tag, prioritize, and even resolve common questions automatically.

Key components of a CX helpdesk include:

• Unified inbox: All messages from every channel appear in one place
• Customer timeline: Complete history of orders, conversations, and interactions
• Automation rules: Smart workflows that tag, route, and respond to tickets
• Integrations: Direct connections to your ecommerce platform and other tools
• Reporting: Analytics on response times, customer satisfaction, and team performance

The best CX helpdesks for ecommerce brands

Choosing the right platform depends on your store's scale, your team's needs, and your primary goals. We evaluated the top options based on their ecommerce integrations, automation capabilities, and ability to drive revenue, not just resolve tickets.

Gorgias

Gorgias is a conversational commerce platform built specifically for ecommerce brands. It combines a powerful helpdesk with an AI Agent designed to both resolve support tickets and convert shoppers into customers. Its deep, two-way integration with Shopify is a core differentiator, allowing teams to manage orders, issue refunds, and create discount codes directly within the helpdesk.

The platform's AI Agent can automate up to 60% of common inquiries like "Where is my order?" process returns, and answer product questions with brand-aligned responses. Beyond support, Gorgias includes revenue-driving tools that proactively engage shoppers with personalized recommendations and targeted chat campaigns.

What makes Gorgias different is its focus on conversational commerce. This means using real-time conversations as your storefront, where support and sales happen in the same place. Your team can recommend products, process orders, and resolve issues without customers ever leaving the chat.

Main features:

• Unified inbox for all channels (email, chat, SMS, social, voice)
• AI Agent that resolves up to 60% of tickets
• Deep Shopify integration for order management
• Convert features for proactive sales
• Automated workflows and Macros
• Help Center builder
• Performance analytics and reporting

Ideal for: Shopify brands doing $1M+ USD in revenue, teams managing 500+ tickets monthly, brands prioritizing sales alongside support

Pricing: Starter: $10 USD/month (50 tickets), Basic: $60 USD/month (300 tickets), Pro: $360 USD/month (2,000 tickets), Advanced: $900 USD/month (5,000 tickets), Enterprise: Custom pricing

Read more: Which Gorgias plan should you choose? (Pricing breakdown)

Zendesk

Zendesk is one of the largest players in the customer service software market, offering a comprehensive suite of tools for businesses of all sizes. Its platform is highly customizable and scalable, making it a popular choice for large enterprises with complex support needs.

While not built exclusively for ecommerce, Zendesk offers robust integrations with Shopify and other platforms. Its strengths lie in its powerful ticketing system, extensive reporting capabilities, and mature AI features that can suggest answers and automate workflows.

However, its general-purpose nature means that achieving the deep ecommerce functionality native to platforms like Gorgias often requires more setup, customization, and reliance on third-party apps. You'll need technical expertise to get the most out of Zendesk's advanced features.

Ideal for: Large enterprises with dedicated IT teams, businesses serving multiple industries, companies needing extensive customization

Pricing: Suite Team: $55 USD/agent/month, Suite Growth: $89 USD/agent/month, Suite Professional: $115 USD/agent/month, Suite Enterprise: Custom pricing

Read more: Zendesk pricing in 2026: Plans, add-ons, and if it’s worth it

Freshdesk

Freshdesk is known for its user-friendly interface and affordable pricing, making it an attractive option for small and medium-sized businesses. It provides a solid set of helpdesk features, including omnichannel ticketing, automation, and a self-service knowledge base.

Its "Freddy AI" offers chatbot capabilities and agent assistance. Like Zendesk, Freshdesk serves a wide range of industries, so its ecommerce features are not as deeply embedded as in specialized platforms. While it integrates with Shopify, the level of direct order management within the helpdesk is more limited.

Freshdesk works well for brands looking for a straightforward and cost-effective helpdesk solution that covers the basics without overwhelming complexity.

Ideal for: Small to medium businesses, teams new to helpdesk software, brands with straightforward support needs

Pricing: Free: $0 USD (up to 10 agents), Growth: $15 USD/agent/month, Pro: $49 USD/agent/month, Enterprise: $79 USD/agent/month

Read more: Freshdesk pricing guide: What you actually pay in 2026

Intercom

Intercom positions itself as a "customer communications platform" with a strong focus on proactive engagement through its live chat and chatbot products. It excels at engaging website visitors, qualifying leads, and onboarding new users, making it popular with SaaS companies and brands with a heavy focus on marketing-led conversations.

For ecommerce, Intercom's strength is in its pre-purchase engagement capabilities. Its chatbots can guide shoppers, recommend products, and capture leads effectively. However, its post-purchase support functionality and deep backend ecommerce integrations are less developed compared to platforms built specifically for support-heavy retail operations.

Ideal for: SaaS companies, businesses focused on lead generation, brands prioritizing pre-purchase engagement

Pricing: Essential: $39 USD/seat/month, Advanced: $99 USD/seat/month, Expert: $139 USD/seat/month

How a CX helpdesk works for ecommerce teams

A modern CX helpdesk streamlines the entire support process into a clear, repeatable workflow. It starts the moment a customer reaches out and ends with a fast, satisfying resolution that strengthens their relationship with your brand.

Here's how the process typically works. A customer sends a message via email, live chat, or a social media DM. The message automatically creates a ticket in a single, shared inbox, so nothing gets lost.

Smart routing happens next. Automation Rules instantly analyze the ticket based on the channel, keywords, or customer history. The ticket gets tagged (like "Return Request") and assigned to the correct agent or team.

When the agent opens the ticket, they immediately see the shopper's complete history in a side panel. This includes past orders from Shopify, previous conversations, and data from other integrated apps. Full context without switching tabs.

For direct actions, if the customer wants to make a return, the agent can process it directly within the helpdesk using an integration. No need to log into Shopify or a separate returns app.

Automation rules handle simple questions automatically. For a question like "Where is my order?" an automated workflow can pull the tracking information from Shopify and send an immediate, personalized reply, resolving the ticket without any agent involvement.

The key workflow components include:

• Message capture: Every customer message becomes a trackable ticket
• Smart tagging: AI identifies the topic and urgency automatically
• Context loading: Customer history and order data appear instantly
• Action execution: Agents can process refunds, edits, and returns in one click
• Resolution tracking: Every interaction is logged for future reference

Why a CX helpdesk matters for customer experience and revenue

Investing in a CX helpdesk isn't just about managing support tickets more efficiently. It's a strategic decision that directly impacts customer loyalty, operational costs, and your bottom line. When support is fast, personal, and helpful, it becomes a key driver of growth.

Retention and lifetime value: Fast, effective support is a major factor in customer retention. Solving a problem quickly and personally makes customers feel valued, encouraging them to make repeat purchases and increasing their lifetime value.

Conversion optimization: A CX helpdesk with proactive chat can engage hesitant shoppers on product or checkout pages. Answering a quick question about sizing or shipping can be the final nudge a customer needs to complete their purchase.

Operational efficiency: By automating repetitive questions and centralizing tools, a helpdesk dramatically reduces the time agents spend on manual tasks. This lowers your cost per ticket and allows a lean team to handle a high volume of conversations.

Revenue generation: Top CX helpdesks empower agents to be salespeople. With full customer context, they can recommend relevant products, upsell accessories, and even create draft orders directly in the chat, turning a support interaction into a sale.

The business impact extends beyond individual transactions. When customers know they can get help quickly, they're more likely to try new products, make larger orders, and recommend your brand to others. Support becomes a competitive advantage rather than just a cost center.

Modern ecommerce customers expect instant responses and personalized service. A CX helpdesk helps you meet these expectations consistently, even as your business grows. The alternative — missed messages, long response times, and frustrated customers — directly hurts your revenue and reputation.

Start delivering better customer experiences today

A CX helpdesk is no longer just a tool for managing complaints. For modern ecommerce brands, it's the engine for building customer relationships, driving revenue, and scaling operations efficiently. By centralizing conversations and automating workflows, you can deliver the fast, personal experiences that today's shoppers expect.

The best time to implement a CX helpdesk is before you need it. Waiting until you're overwhelmed with support requests means you're already losing customers and revenue. Start with a platform that can grow with your business and adapt to your specific needs.

Ready to see how a platform built for ecommerce can turn your support center into a profit center? Book a demo to learn how you can transform every customer conversation into a growth opportunity.

{{lead-magnet-2}}

TL;DR:

• Richpanel charges per agent seat starting at $29 USD/month plus separate fees for its self-service portal based on order volume
• Portal pricing ranges from $9-$99/month for up to 5,000 orders, scaling with volume
• Add-ons like Sidekick AI ($10/seat), social media moderator ($49/month), and WhatsApp integration add to base costs
• Most brands spend $200-$500/month for three to five agents with a portal and basic add-ons
• Gorgias offers transparent ticket-based pricing that often costs less for seasonal businesses

Richpanel uses a dual pricing model that combines seat-based help desk costs with order volume-based portal fees. The platform starts at $29 per agent per month, but real costs quickly climb when you add the self-service portal, AI features, and channel integrations. Understanding how each component affects your total spend helps you budget accurately and compare alternatives. This guide breaks down exactly what you'll pay based on your team size, order volume, and feature needs.

What is included in Richpanel pricing

Richpanel's pricing is built on two separate components that you pay for independently. You pay a per-agent fee for the help desk platform and a separate order-based fee for the self-service portal.

This means your total monthly cost isn't just the number of agents multiplied by the plan price. You must also factor in the cost of the customer-facing portal, which is required for self-service features and scales with your store's monthly order volume.

Seat-based pricing is a model where you pay a fixed monthly fee for each user or agent who has access to the software. This means if you have five agents, you pay five times the monthly rate. Order-based pricing ties costs directly to the number of orders your store processes each month.

The base help desk plans include core features, but many functions that modern ecommerce brands consider essential come at an additional cost:

• Included in base plans: Ticketing system, live chat, email and social media inbox, basic Shopify integration
• Excluded and cost extra: Self-service portal, AI assistance (Sidekick AI), social media comment moderation, channel integrations like WhatsApp or voice

Richpanel help desk plans and costs

Richpanel offers four main help desk tiers, each priced per agent per month. The plan you choose determines what features your support team can access, with significant jumps in functionality and cost between each level.

Starter plan costs

The Starter plan costs $29 per seat per month. It provides the fundamental tools for managing customer conversations, including a unified ticketing inbox, live chat, and basic automation Rules.

This plan is designed for very small teams or new stores just starting to centralize support. However, it lacks key efficiency features like collision detection, which prevents multiple agents from working on the same ticket simultaneously.

Regular plan costs

At $49 per seat per month, the Regular plan is the most common starting point for growing brands. It adds critical features like collision detection, advanced automation capabilities, custom ticket fields, and team collaboration tools.

This tier provides the necessary foundation for a team to handle a moderate volume of inquiries efficiently. Most brands find this plan meets their needs once they have more than two agents handling support.

Pro plan costs

The Pro plan costs $99 per seat per month and is built for larger teams that require deeper insights and control. It unlocks advanced customer interaction analytics, custom user roles and permissions, and API access for building custom integrations.

Brands typically upgrade to Pro when they need to manage multiple teams, enforce stricter access controls, or integrate support data with other business intelligence tools. The price jump from Regular to Pro is significant, so you'll want to ensure you actually need these advanced features.

Enterprise plan costs

The Enterprise plan uses custom pricing and is tailored for high-volume businesses with complex operational needs. It includes everything in Pro, plus features like single sign-on (SSO), a dedicated account manager, custom integration support, and service level agreement (SLA) guarantees.

This plan usually has a minimum seat requirement and is negotiated directly with Richpanel's sales team. Expect to pay significantly more than the Pro plan, often starting at several thousand dollars per month.

Richpanel self-service portal pricing by order volume

The self-service portal is a separate product with its own pricing structure tied to your monthly order volume. This is an additional cost on top of your help desk seat licenses.

The portal allows your shoppers to track orders, initiate returns, and find answers in a knowledge base without contacting an agent. This means you're essentially paying for two products: the agent-facing help desk and the customer-facing portal.

Base plan up to 5,000 orders

For stores processing up to 5,000 orders per month, the portal costs between $9 and $29 per month, depending on your help desk plan. This tier includes essential self-service features like order tracking, basic returns management, and a knowledge base.

The portal requires a direct sync with your Shopify store to function properly. Without this integration, customers can't access their order information or complete self-service actions.

Pro plan up to 20,000 orders

As your order volume grows, so does the portal cost. The Pro portal plan is for stores with up to 20,000 monthly orders and costs between $49 and $99 per month.

It adds advanced features like deflection analytics to measure self-service success, custom branding for the portal, and multilingual support. The deflection analytics help you understand how many tickets the portal is preventing, which can justify the additional cost.

Enterprise plan custom volume

For brands exceeding 20,000 orders per month, the portal pricing is custom and negotiated as part of an Enterprise package. This tier offers volume-based discounts and advanced capabilities tailored to high-scale operations.

The exact cost depends on your order volume, but expect to pay several hundred dollars per month for portal access at this level.

Richpanel add-ons and extra fees

Beyond the help desk and portal, several add-ons can significantly increase your total monthly spend. Many of these aren't optional extras but necessary components for running a comprehensive support operation.

Sidekick AI at per seat pricing

Sidekick AI, Richpanel's AI assistant, costs an additional $10 per seat per month. It provides agents with suggested responses, sentiment detection, and auto-tagging for tickets.

Because it's priced per seat, this cost multiplies across your entire team. For a team of five agents, this adds $50 to your monthly bill on top of your base plan costs.

Social media moderator AI at monthly fee

The social media moderator is a separate AI tool for managing Instagram and Facebook comments. It costs a flat fee of $49 per month for the entire account, regardless of how many agents you have.

This tool helps filter spam, hide negative comments, and create tickets from relevant social media interactions. Unlike Sidekick AI, this is an account-wide fee rather than a per-seat charge.

Automation success kit at one-time fee

For teams that need help with setup, Richpanel offers an "Automation Success Kit" for a one-time fee of $499. This package includes guided onboarding, workflow templates, and training sessions to help you get the most out of the platform's automation features.

While this is optional, many brands find they need this support to properly configure their workflows and automation Rules.

WhatsApp and phone via third parties

Integrating channels like WhatsApp or voice isn't native to Richpanel and requires using third-party providers. This introduces variable and often unpredictable costs that can significantly impact your monthly spend.

WhatsApp integration relies on the WhatsApp Business API, which has its own fees based on message volume. Voice support requires a separate telephony provider with its own monthly fees and per-minute charges. These integrations can add anywhere from $50 to several hundred dollars to your monthly expenses, depending on usage.

How Richpanel pricing scales with seats, orders, and channels

Your total cost for Richpanel is driven by three main factors that compound: the number of agent seats, your monthly order volume, and the channels you support. A small change in one area can have a significant impact on your overall bill.

Seats per agent drive base costs

The largest and most direct cost driver is the number of agent seats. Each agent you add increases your monthly bill by the price of your chosen help desk plan.

This linear scaling means you need to be mindful of team size, especially if you rely on seasonal or part-time agents who may only need access for a few months a year. Unlike ticket-based pricing models, you pay for seats whether they're actively used or not.

Consider these monthly costs for different team sizes:

• Three agents on Regular plan: $147/month
• Five agents on Regular plan: $245/month
• Ten agents on Pro plan: $990/month

Monthly orders drive portal fees

Your self-service portal fees are tied directly to order volume, which can create cost spikes during peak seasons like Black Friday Cyber Monday (BFCM). A brand that typically processes 4,000 orders a month might suddenly jump to 15,000 orders in November, pushing them into a higher, more expensive portal tier for that month.

This creates unpredictable costs during your busiest sales periods, when you're already dealing with increased support volume and potentially higher staffing costs.

Channels and voice add integration costs

Each additional support channel, especially voice and WhatsApp, adds another layer of cost and complexity. These often require separate subscriptions with third-party providers, making it difficult to forecast your total monthly spend.

Managing multiple vendors for core support functions also increases administrative overhead and can create gaps in your customer experience if integrations break or providers change their pricing.

Richpanel pricing vs Gorgias pricing for Shopify brands

When comparing Richpanel to other platforms, the most significant difference is the pricing model. Richpanel uses a traditional per-seat model, while a Shopify-native ecommerce helpdesk like Gorgias uses a ticket-based model.

A ticket-based pricing model means you pay based on the number of customer conversations you handle, not the number of agents on your team. This offers more flexibility, especially for businesses with fluctuating support volumes or seasonal patterns.

Here's how the models compare:

• Richpanel approach: Fixed monthly cost per agent plus order-based portal fees
• Gorgias approach: Variable cost based on actual ticket volume with all features included
• Seasonal impact: Richpanel costs stay fixed regardless of ticket volume; Gorgias costs scale with actual support needs
• Team flexibility: Richpanel requires paying for each agent seat; Gorgias allows unlimited agents within ticket limits

For brands with high seasonality, a ticket-based model like Gorgias often provides a lower total cost of ownership. You only pay for the support you actually provide, so your costs naturally scale down during slower months.

In contrast, a seat-based model requires you to pay for agent licenses year-round, even if they're not fully utilized during off-peak periods.

The help desk migration process from Richpanel to Gorgias is streamlined, with dedicated support to ensure a smooth transition of data and workflows. Most migrations take two to four weeks and include transferring your ticket history, macros, and automation Rules.

Alternatives to Richpanel pricing for ecommerce helpdesks

The customer support landscape offers several alternatives, each with a different approach to pricing and features. Understanding these options helps you make an informed decision about which model works best for your business.

Zendesk uses a per-seat model similar to Richpanel but with more complex tiers and add-ons.

Freshdesk also uses a per-seat model with various tiers. It offers a free plan with limited features, but costs can escalate quickly as you add agents and functionality. The free plan is often too restrictive for growing ecommerce brands.

Re:amaze is a more direct competitor in the ecommerce space and uses a per-user model. It bundles many features that Richpanel charges extra for, but can become costly for larger teams due to its per-user pricing structure.

When evaluating alternatives, look beyond the sticker price and consider the total cost of ownership:

• Implementation time: How long does it take to get up and running
• Third-party integrations: What additional tools and costs are required
• Seasonal flexibility: How well does the pricing model align with your business patterns
• Feature completeness: What's included versus what costs extra

See how Gorgias compares for your brand

Choosing a help desk is a major operational decision that affects your team's efficiency and your customers' experience. The right platform aligns with your budget, scales with your growth, and empowers your team to drive revenue rather than just resolve tickets.

Gorgias offers transparent, ticket-based pricing with no hidden fees for channels or users. Your costs are always tied to business activity, not arbitrary seat counts. Our AI Agent can reduce your support costs while increasing sales through intelligent automation and shopping assistance.

To see exactly what you would spend and how our platform can transform your customer experience, book a demo with one of our specialists.

{{lead-magnet-2}}