Customer effort score calculator
Turn a list of effort ratings into one score: answers of 5, 6, 7, 6 and 5 give a customer effort score of 5.8 on the seven-point scale. The count, sum, lowest and highest rating come with it. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Ratings
- 5, 6, 7, 6, 5
- Customer effort score
- 5.8
- Mean
- 5.8
- Quantity
- 5
- Sum
- 29
Customer Effort Score (CES) is the average of how easy customers say it was to complete a request with your company. Support, product, and CX teams collect individual Likert ratings after a ticket, a checkout, or a self-service flow, then need a single number they can trend week over week. This customer effort score calculator takes a non-empty list of those ratings and returns the arithmetic mean — the CES — together with count, sum, minimum, and maximum. Each rating must be a finite number on the CES 2.0 scale from one (strongly disagree that the company made it easy) to seven (strongly agree). Traditional one-to-five CES ratings also fall inside that range and are accepted.
What Customer Effort Score measures and how the mean is formed
Customer Effort Score began as a CEB (now Gartner) survey item that asked how much effort a person personally had to put forth to handle a request, originally on a one-to-five scale where a lower number meant less effort. The widely used CES 2.0 wording flipped the statement to “the company made it easy for me to handle my issue” and stretched the Likert to seven points, from strongly disagree at one to strongly agree at seven, so that a higher mean now means the experience felt easier.
In both versions the headline metric that operators publish is the same identity: add every individual rating and divide by the number of ratings. Five, six, seven, six, and five sum to twenty-nine over five responses, which is a CES of five point eight. One, two, three, four, five, six, and seven sum to twenty-eight over seven, which is a CES of four — the midpoint of the seven-point scale and a signal that the sample is mixed rather than clearly easy.
A single valid rating is a legitimate sample of size one: the mean equals that rating, count is one, and min equals max. What is never legitimate is an empty list. Ratings outside one through seven are also rejected: a nine is not a CES 2.0 box, and a zero is not a Likert point on this instrument.
The mean uses every observation equally; it is not a top-box percentage, not NPS (promoters minus detractors), and not CSAT. Those sibling metrics answer different search intents. Here the contract is the arithmetic mean of the effort ratings you already collected, rounded half-up to six decimal places so goldens stay byte-stable across runtimes.
Where a CES calculator earns its keep
Support operations use a customer effort score calculator after each resolved ticket so a queue, a vendor, or a self-serve article can be ranked by how hard it felt, not only by handle time. Product teams wire the same mean into checkout, password-reset, and returns flows: if CES falls after a redesign, the change added friction even if conversion looked flat for a week.
Classrooms and research methods courses also search for customer effort score when they teach survey design: they need the empty-list error to stay an error, not a silent zero, so students learn that a missing wave of data is not a score of zero effort. Related searches such as net promoter score and customer satisfaction score are different questions with different formulas; do not paste CES ratings into an NPS promoter bucket.
Keep batches within the ten-thousand-rating cap, send the raw list once, and read mean, count, min, and max from a single response. Prefer this contract over a generic mean calculator when the search intent is CES: the scale bounds, the empty-list rule, and the field names match how CX teams talk about effort.
What you can do with it
Support ticket follow-up
After each resolved request, collect 1–7 CES ratings and average them by queue, agent group, or article so you can see which paths feel hard.
Checkout and self-service CX
Score password reset, returns, and checkout flows with the same CES mean after a redesign, and catch added friction before conversion moves.
Board and QBR reporting
Compute a deterministic CES for the quarter from the raw Likert column so the browser check and the warehouse job never disagree on rounding.
FAQ
How is customer effort score calculated?
Five, six, seven, six, five yields 29 / 5 = 5.8.
What scale does this CES calculator use?
CES 2.0 Likert from 1 (strongly disagree that the company made it easy) to 7 (strongly agree). Traditional 1–5 CES ratings fall inside that range and are accepted.
What happens if the ratings list is empty?
An average of zero answers is not a Customer Effort Score, and empty input is not billed.
Is a higher CES better or worse?
On the CES 2.0 wording used here, higher is better: seven means customers strongly agree the company made it easy. This is not the original 1–5 “how much effort” item where lower meant less effort.
Is CES the same as NPS or CSAT?
No. CES is the plain average of effort ratings, with every answer weighted equally. It is not a top-box percentage, not NPS with promoters minus detractors, and not a satisfaction score.
Related tools
For developers — API access
Everything on this page is available programmatically. This section is for teams who want to wire it into their own systems; everyone else can just use the tool above.
API endpoint
Prefer to automate it? One authenticated POST creates the task; the result comes back by webhook or a signed link. The same capability also runs here on the web, by email and from Telegram — and soon from our app too.
Call it from your stack
curl -X POST https://api.kit.forhosting.com/fin/customer-effort-score \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"ratings":[5,6,7,6,5]}'const res = await fetch("https://api.kit.forhosting.com/fin/customer-effort-score", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"ratings": [
5,
6,
7,
6,
5
]
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/fin/customer-effort-score",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"ratings": [
5,
6,
7,
6,
5
]
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/fin/customer-effort-score", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"ratings":[5,6,7,6,5]}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"ratings":[5,6,7,6,5]}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/fin/customer-effort-score", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"ratings": [
5,
6,
7,
6,
5
]
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "fin.customer_effort_score",
"status": "queued",
"_links": {
"result": "/tasks/tsk_…/result"
}
}The API is asynchronous: the call returns a task_id immediately and the result arrives by webhook. Polling is capped at 1 req/s per task.
Pricing
Published price — no tokens, no invented credits. A failed task is never charged.
Limits
max_items | 10000 |
Errors
| HTTP | Code | Meaning |
|---|---|---|
401 | unauthorized | Missing or invalid API key. |
402 | insufficient_balance | Your balance doesn't cover the task price. |
404 | unknown_type | That task type doesn't exist. |
429 | rate_limited | Too many requests. Use the webhook instead of polling. |
Technical notes
Empty rating lists are rejected with invalid_input and are never billed, because an average of nothing is not a score.
What Customer Effort Score measures and how the mean is formed
There is no average of zero answers, so this calculator fails with invalid_input instead of inventing a zero CES that would look like a terrible quarter in a dashboard.
Input contract, response shape, and error behaviour
POST a JSON body with one required field named ratings: a non-empty array of finite numbers, each between one and seven inclusive. Aliases scores, responses, and values are accepted and behave the same, so a warehouse export that already labels the column scores does not need a rename step. On success the body includes customer_effort_score (the CES, identical to mean), mean, count as n, sum of the ratings, min, max, scale_min of one, scale_max of seven, and a formula string restating CES equals the sum of ratings divided by n on the one-to-seven CES 2.0 Likert scale. Example: ratings five, six, seven, six, five yield customer_effort_score five point eight, count five, sum twenty-nine, min five, and max seven. Failed validation — missing ratings, an empty list, a non-finite entry, a value below one or above seven, or a list longer than ten thousand ratings — returns invalid_input naming the problem and is never charged. Ten thousand is the published size cap: enough for a busy support week or a quarterly dump, small enough for a Worker isolate and a browser tab. Pair the response with your own time series if you need a chart; this endpoint computes the mean of the batch you sent and does not store history, does not weight recency, and does not drop outliers. Pricing is a flat $0.002 per successful request with unit item.
Where a CES calculator earns its keep
Failed tasks that return invalid_input do not consume prepaid balance, which keeps exploratory scripts cheap while someone pastes an empty column by mistake.
Technical questions
What does the customer effort score calculator cost?
The browser tool is free. API requests use prepaid KIT balance at $0.002 per successful call; invalid input is not billed.