Linear grade curve calculator
Give every student the same 5 bonus points after a hard exam and watch the class mean move, from 79 to 84 in the worked example. No curved score goes past 100%, and you see how many students hit that cap. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Scores
- 72, 85, 91, 68
- Points
- 5
- Curved scores
- 77, 90, 96, 73
- Max score
- 100
- Quantity
- 4
- Capped count
- 0
A linear grade curve is the simplest classroom adjustment after a hard exam: add the same fixed number of points to every raw percent score, then refuse to publish anything above one hundred percent.
What a linear add-points curve means and how the 100% cap works
In many secondary and college courses, a linear grade curve means adding a constant bonus to every raw percent score after an assessment that ran too hard relative to the intended difficulty. If the class wrote an exam scored out of one hundred and the instructor decides five points of relief are fair, each raw score r becomes min(100, r + 5).
The minimum with one hundred is essential: without it, a student who already earned ninety-seven would appear at one hundred two, which most grade books and transcript systems reject or silently clamp later. The capability does not re-scale the distribution, does not force the top score to one hundred, and does not apply a multiplicative factor; those are different curving policies (for example, proportional curves or ranking curves) and belong to other tools.
Here the only free parameters are the list of raw percent scores and the non-negative constant points to add. Scores may be slightly outside zero to one hundred if your source grade book uses extra credit or incomplete data; the curve still adds points and still clamps only the upper side at one hundred.
When a flat bonus for everyone makes sense
Learning management systems and grade-export pipelines need a deterministic oracle so every client—web, mobile, or batch CSV import—agrees on curved percents for the same raw list and bonus. Teaching assistants can paste a section’s scores, try two or three point values, and pick a curve that lifts the mean without creating a pile-up above one hundred that the registrar will not accept. Content sites can demonstrate fair curving without shipping spreadsheet macros that break on locale decimal separators.
Failed validation does not consume balance.
What you can do with it
Post-exam curve previews
Paste a section’s raw percent scores and try a fixed bonus (for example five or ten points) to see curved scores and who hits the 100% cap before publishing.
FAQ
How does the linear grade curve calculator work?
Send scores as an array of finite raw percent scores and points as a non-negative bonus. Each curved score is min(100, raw + points).
What happens to a score that would go above 100%?
It is capped at 100. Each curved score is the raw score plus your points or 100, whichever is lower, and the result tells you how many students hit that ceiling so you can judge whether the bonus is too generous.
Does a linear curve change the gaps between students?
No. Everyone gets the same points, so the distance between two students stays the same unless one of them reaches the cap. It does not rescale the scores or push the top score to 100.
Can I use zero points?
Yes. Zero adds nothing and simply shows your raw scores with the class mean, which is a quick way to check the list before you try a real bonus. Negative points are not accepted.
How many scores can I curve at once?
Between 1 and 500 in one go, in the order you enter them, so a whole section or a full course fits in a single run and each student keeps their place in the list.
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/edu/linear-grade-curve \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"scores":[72,85,91,68],"points":5}'const res = await fetch("https://api.kit.forhosting.com/edu/linear-grade-curve", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"scores": [
72,
85,
91,
68
],
"points": 5
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/edu/linear-grade-curve",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"scores": [
72,
85,
91,
68
],
"points": 5
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/edu/linear-grade-curve", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"scores":[72,85,91,68],"points":5}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"scores":[72,85,91,68],"points":5}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/edu/linear-grade-curve", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"scores": [
72,
85,
91,
68
],
"points": 5
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "edu.linear_grade_curve",
"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
This linear grade curve calculator accepts an array of raw scores and a non-negative points bonus, computes curved_i equals the minimum of one hundred and raw_i plus points for each student, and returns the full curved list, the count of scores that hit the ceiling, and class means before and after the adjustment. The same pure arithmetic powers the free browser tool and the API path, so grading scripts and homework demos stay byte-stable. Missing scores, empty arrays, negative points, and non-finite values fail with invalid_input instead of inventing a curve.
What a linear add-points curve means and how the 100% cap works
This endpoint encodes that classroom convention directly: curved equals min(100, raw plus points) for every entry in the scores array, in the same order you sent them. Negative bonuses are rejected because this product page and API contract describe an add-points linear curve, not an across-the-board deduction. Zero points is allowed and acts as a pure validation pass that still reports means and a capped_count of zero unless a raw score already exceeded one hundred and is clamped by the same max rule. That predictability lets TAs preview what a proposed curve would do before publishing final grades.
Input contract, response shape, and error behaviour
POST a JSON body with two required fields: scores, a non-empty array of finite numbers (one to five hundred entries), and points, a non-negative finite number of bonus points to add to every raw score. Each score element and the points field may arrive as a JSON number or as a numeric string; aliases raw_scores, grades, and values map to scores, while points_to_add, bonus, curve_points, and add map to points. Missing scores, a non-array scores value, an empty list, more than five hundred entries, missing points, negative points, NaN, Infinity, and non-numeric elements fail with invalid_input and messages that name the field or index. Those validation failures are not billed. On success the body echoes the cleaned scores array and points value, returns curved_scores in the same order, sets max_score to one hundred, reports count as the class size, capped_count as how many students landed exactly at the ceiling because raw plus points exceeded one hundred, and includes mean_raw and mean_curved as arithmetic means for quick before-and-after comparison. The formula string restates curved equals min(100, raw plus points) and method is linear_grade_curve. Example: scores seventy-two, eighty-five, ninety-one, sixty-eight with five points yields seventy-seven, ninety, ninety-six, seventy-three, none capped if none crossed one hundred; a raw ninety-eight with five points becomes one hundred and increments capped_count. Pair the lists with your own letter-grade bands if you need A–F labels; this endpoint applies only the numeric linear curve and does not emit letter grades, weights, or category averages.
Where a linear grade curve API earns its keep
Keep requests within the five-hundred-score limit, pin curved_scores and means in tests, and you get reproducible linear curves for LMS plugins, office-hour demos, and edge workers without standing up custom grading infrastructure of your own.
Integration use cases
LMS and grade-export automation
Apply the same min(100, raw + points) rule in batch pipelines so every client agrees on curved percents and capped_count.
Teaching-assistant fairness checks
Compare mean_raw and mean_curved for candidate point values and document a transparent linear curve for students.
Technical questions
What is the maximum curved score?
One hundred percent. If raw plus points would exceed 100, the result is capped at 100 and counted in capped_count.
Can I add a negative number of points?
No. This endpoint implements an add-points linear curve only. Negative points fail with invalid_input; use a different policy if you need deductions.
How many scores can I curve at once?
Between 1 and 500 finite numbers per request. Larger rosters should be split into batches.
What does the linear grade curve calculator cost?
The browser tool is free. API requests use prepaid KIT balance at $0.002 per successful call; invalid input is not billed.