Calculate OKR key result progress percentage
A key result that started at 20, now sits at 65 and aims for 100 is 56.25% complete, because progress is measured from the starting value. Goals that should fall, like response time, work the same way. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Starting value
- 20
- Current value
- 65
- Target value
- 100
- Progress percent
- 56.25
This OKR key result progress calculator converts a starting value, a current measurement, and a target value into one clear percentage. It works for goals that should increase, such as revenue or retention, and goals that should decrease, such as response time or defect count. The calculation preserves progress beyond the usual zero-to-one-hundred range, making setbacks and exceeded targets visible instead of hiding them behind artificial limits. Use it for a single review or as a deterministic building block in reporting automation.
Measure movement from the actual baseline
An OKR percentage is meaningful only when it starts from the value recorded at the beginning of the cycle. The calculator measures how much of the full baseline-to-target distance the current result has covered. For example, moving from 20 to 60 when the target is 100 covers half of the required distance, so progress is 50 percent.
This differs from simply dividing the current value by the target, which would incorrectly report 60 percent and ignore the work already represented by the baseline. Keep all three inputs in the same unit and scope: do not mix monthly revenue with annual revenue, seconds with milliseconds, or a regional baseline with a company-wide current result. Use measurements from consistent sources whenever possible.
The returned percentage is rounded to six decimal places, which keeps automated reports stable while retaining enough precision for unusually small movements.
Use the same formula for increasing and decreasing results
The directional formula handles both kinds of key result without a separate mode. For an increasing goal, the target is above the starting value and a higher current value normally means more progress. For a decreasing goal, the target is below the starting value and a lower current value normally means more progress.
Imagine reducing average resolution time from 12 hours to 4 hours. A current value of 8 hours is halfway across that eight-hour improvement, so the result is 50 percent. The signs in the formula cancel correctly because both the achieved movement and the required movement are negative.
This behavior is useful for cost, churn, defects, latency, emissions, and other metrics where improvement means reduction. Negative numeric values are otherwise valid when the underlying metric genuinely supports them, such as net cash flow or a temperature-based operational measure.
Interpret setbacks and overachievement without hiding them
The output is deliberately not clamped between zero and one hundred. A negative percentage means the current value moved away from the target relative to the baseline. A value above 100 percent means the result passed the stated target in the intended direction.
Those outcomes carry useful management information: clamping a setback to zero conceals deterioration, while clamping overachievement to one hundred conceals how far a team exceeded its commitment. Treat the number as a measurement rather than a complete performance judgment. Before comparing key results, consider whether their baselines, targets, update dates, and confidence levels are equally reliable.
If your dashboard needs a visual bar limited to 100 percent, keep this raw percentage in the data and clamp only the display layer, so analysis and audit records retain the real result. In automation, run the calculation after validating or approving the newest measurement, then store the three source values beside the percentage. That makes later changes explainable and prevents a rounded display number from becoming the only surviving record.
What you can do with it
Update a quarterly OKR dashboard
Turn each approved key result measurement into a consistent progress percentage for the current reporting cycle.
Track a reduction target
Measure progress toward lower churn, fewer defects, shorter response times, or another goal where improvement means decreasing the value.
Audit progress calculations
Recalculate a reported percentage from its baseline, latest measurement, and target to verify that the baseline was not omitted.
FAQ
What formula does the calculator use?
It calculates (current value minus starting value) divided by (target value minus starting value), then multiplies the result by 100.
Can it calculate progress for a target that should decrease?
Yes. The directional formula works when the target is below the starting value, so reduction goals do not need a separate setting.
Why can the result be negative or greater than 100 percent?
Negative progress shows movement away from the target, while a result above 100 percent shows that the current value has passed the target.
Why is an equal starting value and target rejected?
The required movement would be zero, making the progress calculation a division by zero with no defined percentage.
Why not just divide the current value by the target?
Because that ignores where you started. Moving from 20 to 60 with a target of 100 covers half the distance, so progress is 50%, while 60 divided by 100 would wrongly report 60%.
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/biz/okr-progress-percent \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"starting_value":20,"current_value":65,"target_value":100}'const res = await fetch("https://api.kit.forhosting.com/biz/okr-progress-percent", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"starting_value": 20,
"current_value": 65,
"target_value": 100
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/biz/okr-progress-percent",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"starting_value": 20,
"current_value": 65,
"target_value": 100
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/biz/okr-progress-percent", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"starting_value":20,"current_value":65,"target_value":100}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"starting_value":20,"current_value":65,"target_value":100}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/biz/okr-progress-percent", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"starting_value": 20,
"current_value": 65,
"target_value": 100
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "biz.okr_progress_percent",
"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. |
Technical notes
Measure movement from the actual baseline
Enter that baseline as starting_value, the latest trustworthy measurement as current_value, and the desired endpoint as target_value.
Use the same formula for increasing and decreasing results
The target cannot equal the starting value because there would be no measurable distance to divide by; that input returns a typed error.
Technical questions
How much does an API calculation cost?
Each API request costs $0.002. The browser version can run the same deterministic calculation locally.