Calculate product return rate from units sold and returned
Product return rate shows what percentage of sold units came back during the same reporting period.
Run — free
Enter the number of units sold and the number returned to receive a consistent percentage you can use in merchandising, operations, and financial reporting. The calculator applies the standard returned-units-divided-by-sold-units formula, validates both counts, and clearly rejects a zero sales denominator. It is useful for a single SKU, a category, a store, or an entire catalog, provided both figures cover the same period and scope.
Choose matching sales and return counts
A useful return rate starts with two counts that describe the same slice of the business. Select one reporting period, such as a calendar month, and one scope, such as a SKU, product category, store, marketplace, or complete catalog. Enter every unit sold in that scope as units sold and every unit returned during that scope and period as units returned. Do not mix order counts with item counts: an order containing three products represents three sold units, while one returned product represents one returned unit. Keep cancellation data separate unless your organization formally classifies fulfilled cancellations as returns. The calculator accepts whole, non-negative counts because physical units are discrete. Sales must be greater than zero; without sold units there is no meaningful denominator and therefore no percentage to report. Returns can be zero, producing a zero percent rate. In some operational datasets returned units can exceed current-period sold units because customers return purchases made earlier. The calculator preserves that valid signal instead of silently capping the result at one hundred percent.
Understand the percentage calculation
The formula is straightforward: divide units returned by units sold, then multiply the quotient by one hundred. If a shop sold 1,250 units and recorded 37 returns, the calculation is 37 divided by 1,250, multiplied by 100, which produces 2.96 percent. The result is rounded to no more than six decimal places so repeated API calls and browser calculations remain stable while retaining enough precision for large catalogs and low-volume return events. A rate is a relationship, not a diagnosis. A higher percentage might reflect sizing problems, damage, inaccurate descriptions, customer expectations, a generous policy, or the timing difference between purchase and return. Compare rates only when the underlying counting rules are consistent. If one report uses shipped units and another uses placed-order units, their percentages are not directly comparable. The returned output repeats both submitted counts alongside the percentage, making it easier to audit a dashboard value and confirm which denominator produced it. Store those counts with the rate whenever reproducibility matters.
Use return rate in recurring analysis
For ongoing monitoring, calculate the rate on a consistent schedule and retain each period's inputs. Weekly results can surface sudden fulfillment or quality issues, while monthly results usually reduce noise for products with modest volume. Segment the calculation by SKU, supplier, category, sales channel, warehouse, or campaign to find patterns hidden by a catalog-wide average. Always interpret small denominators carefully: one return from two sales is fifty percent, but that observation is less stable than five hundred returns from one thousand sales. Pair the percentage with sold volume, return reasons, refund value, and contribution margin before making assortment decisions. When automating the calculation, send integer counts gathered from the same reporting cutoff and treat a zero-sales error as a prompt to display “not applicable,” not as zero percent. The browser version is convenient for individual checks, while API requests cost $0.002 each and suit scheduled reports or data pipelines. Because the calculation is deterministic and uses no external services, identical valid inputs always produce identical output.
What you can do with it
Compare product performance
Calculate the rate for each SKU using the same period and counting rules to identify products that need closer review.
Monitor fulfillment changes
Track weekly or monthly return percentages after packaging, carrier, warehouse, or quality-control changes.
Build commerce reports
Add a repeatable return-rate field to dashboards while retaining the sold and returned counts used in the calculation.
FAQ
What formula does the calculator use?
It divides units returned by units sold and multiplies the result by 100.
What happens when units sold is zero?
The calculation returns an invalid-input error because a percentage cannot be calculated with a zero denominator.
Can units returned be zero?
Yes. Zero returned units with a positive number of sold units produces a return rate of 0 percent.
Can the result exceed 100 percent?
Yes. This can occur when returns recorded in the period include products sold before the reporting period.
How much does an API calculation cost?
Each API request costs $0.002. The calculator is also available to run in the browser.
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/ecom/return-rate-calculate \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"units_sold":1250,"units_returned":37}'const res = await fetch("https://api.kit.forhosting.com/ecom/return-rate-calculate", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"units_sold": 1250,
"units_returned": 37
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/ecom/return-rate-calculate",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"units_sold": 1250,
"units_returned": 37
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/ecom/return-rate-calculate", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"units_sold":1250,"units_returned":37}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"units_sold":1250,"units_returned":37}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/ecom/return-rate-calculate", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"units_sold": 1250,
"units_returned": 37
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "ecom.return_rate_calculate",
"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.
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. |