ForHosting KIT · Education

Grade percentage from fraction

17 correct out of 20 is 85%, a B in the 83–86% band. Type the points earned and the points possible, even with half points of partial credit, and get the percentage and a letter with plus and minus steps. Free in your browser.

Free
Runs in your browser
No sign-up
Your data stays on your device

Run — free How it works & API

Use it from WebAPIEmailTelegramApp soon

Worked example

If you enter

Total: 20
Correct: 17

You get

Fraction label: 17/20
Percentage: 85
Percent label: 85%
Letter grade: B

Teachers, tutors, and students mark quizzes and homework as a simple fraction: how many correct out of how many possible. Reporting that result as a percentage and a letter grade is the step that still eats time when the total is odd—seventeen out of twenty, forty-three out of fifty, nine and a half out of twelve for partial credit. This grade percentage from fraction tool does that conversion in one shot: divide correct by total, multiply by one hundred, round with a stable half-up rule, and map the rounded percent onto a transparent US ten-point letter scale with plus and minus bands. No curve, no weights, and no network call—just the quickest way to grade a marked test out of any total and show both percent and letter.

How the fraction becomes a percentage and letter

A marked test is a fraction: correct answers or points earned in the numerator, total questions or maximum points in the denominator. The percentage grade is correct divided by total, multiplied by one hundred. Seventeen correct on a twenty-item quiz is eighty-five percent; forty-three of fifty is eighty-six percent; nine correct on twelve is seventy-five percent.

Partial credit is allowed when correct is not a whole number—for example nine point five of twelve—as long as correct stays non-negative and does not exceed total. Total must be a positive finite number so division is defined; a zero-total paper is rejected rather than inventing a score. After the raw percent is computed, half-up rounding to the chosen decimal places produces the display percentage that students and parents see.

Letter grades use a common US ten-point scale on that rounded percent: A-plus from ninety-seven upward, A from ninety-three, A-minus from ninety, then B, C, and D bands with plus and minus steps of about three to four points, and F below sixty. The response also returns the inclusive band minimum and maximum for the assigned letter so you can show “B, 83–86 percent” next to the score without a second lookup table.

What you enter and what you get back

Numeric strings are accepted; booleans, objects, empty strings, and non-finite values are rejected. correct must not exceed total—bonus points above one hundred percent are out of scope for this simple fraction grader. Optional decimals is an integer from zero through six and defaults to two; it controls half-up rounding of the percentage and of the echoed correct and total values. Example: correct 17 and total 20 with default decimals yields eighty-five percent and letter B.

Example: correct 20 and total 20 with decimals zero yields one hundred percent and A-plus.

Where turning fractions into grades saves time

Classroom teachers finish a stack of short quizzes and need percent and letter for the gradebook without opening a spreadsheet for every odd total. Tutoring centers post weekly progress as “score out of total” and want a consistent letter for parent reports. Student portals and LMS plugins convert raw item counts from optical readers or auto-graded quizzes into a display percent and letter before the weighted category average runs elsewhere.

Homework help pages can embed the free browser path so learners check “what is fifteen out of eighteen as a percent and letter” without a model call. Failed validation does not consume balance. Document the letter scale beside the result, pin rounded percentages in tests, and you get reproducible grading helpers for edge workers, FAQ bots, and teacher tools without maintaining a private conversion spreadsheet of your own.

What you can do with it

Quick classroom quiz grading

Turn correct-over-total counts from a marked quiz into percent and letter for the gradebook in one step.

Student self-check after practice tests

Let learners enter items right and total items to see percentage and letter before the official LMS posts results.

LMS and gradebook automation

Map raw score fractions from scanners or quiz engines into stable percent and letter fields for exports and parent portals.

FAQ

How do you convert a test fraction to a percentage grade?

Divide correct by total and multiply by 100. For example, 17/20 is 85%. This tool also maps the rounded percent to a US letter grade (A+ through F).

What letter grade scale is used?

A common US ten-point scale with plus/minus: A+ from 97, A from 93, A- from 90, B+ from 87, B from 83, B- from 80, C+ from 77, C from 73, C- from 70, D+ from 67, D from 63, D- from 60, and F below 60. Band min and max are returned with the letter.

Can correct or total be fractional for partial credit?

Yes. correct may be a non-negative non-integer (for example 9.5) as long as it does not exceed total. total must be a positive finite number.

What percentage is 17 out of 20?

It is 85 percent, a B. Dividing 17 by 20 and multiplying by 100 gives 85, which sits in the B band from 83 to 86 percent on the ten-point US scale.

Can the score be higher than the total for bonus points?

No. The points earned cannot exceed the points possible, so results above 100 percent are outside this grader. A test with zero possible points is also refused, because there is nothing to divide by.

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

POSThttps://api.kit.forhosting.com/edu/grade-percentage-from-fraction

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/grade-percentage-from-fraction \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d '{"correct":17,"total":20}'

const res = await fetch("https://api.kit.forhosting.com/edu/grade-percentage-from-fraction", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.KIT_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "correct": 17,
    "total": 20
  })
});
const { task_id } = await res.json();

import os, requests

res = requests.post(
    "https://api.kit.forhosting.com/edu/grade-percentage-from-fraction",
    headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
    json={
    "correct": 17,
    "total": 20
},
)
task_id = res.json()["task_id"]

<?php
$res = file_get_contents("https://api.kit.forhosting.com/edu/grade-percentage-from-fraction", false, stream_context_create([
  "http" => [
    "method"  => "POST",
    "header"  => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
    "content" => '{"correct":17,"total":20}',
  ],
]));
$task = json_decode($res, true);

body := bytes.NewBufferString(`{"correct":17,"total":20}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/edu/grade-percentage-from-fraction", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)

Example request

{
  "correct": 17,
  "total": 20
}

Example response

{
  "task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
  "type": "edu.grade_percentage_from_fraction",
  "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

Per request$0.002

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

Input contract, response fields, and validation

Send a JSON object with required correct and total fields. correct is a non-negative finite number (points earned or items right); total is a positive finite number (maximum points or item count). Optional aliases include right, score, earned, and numerator for correct, and max, out_of, denominator, and possible for total, so thin clients can reuse familiar field names. On success the body returns correct and total, fraction_label such as 17/20, percentage as a number, percent_label with a percent sign, letter_grade such as B, band_min and band_max for that letter, formula, scale as a compact band summary, decimals, and a short message sentence for UI copy. Missing fields, non-numeric input, total not positive, correct above total, or decimals outside zero through six throw invalid_input and are not billed.

Technical questions

What inputs are rejected?

Missing correct or total, non-numeric values, total not greater than zero, correct greater than total, or decimals outside 0–6 fail with invalid_input and are not billed.

What does the grade percentage from fraction calculator cost?

The browser tool is free. API requests use prepaid KIT balance at $0.002 per successful call; invalid input is not billed.

Read the full KIT documentation →

Run — free