Abundant number checker
The proper divisors of 12 are 1, 2, 3, 4 and 6, which add up to 16, so 12 is abundant by 4. Enter any positive whole number to see its divisor sum, the excess and a clear yes or no. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Positive integer to classify
- 12
- Aliquot sum
- 16
- Abundance
- 4
The abundant number checker answers a classical number-theory question: does the sum of the proper positive divisors of n exceed n itself? The engine uses deterministic trial division up to the square root of n, so the result is exact, free of floating-point drift, and identical on every run. It never calls the network, never samples randomness, and never depends on the clock.
What abundant means and what you see
A positive integer n is abundant when its aliquot sum — the sum of all positive divisors of n excluding n itself — is strictly greater than n. Equivalently, the abundance amount defined as aliquot sum minus n is a positive integer. The smallest abundant number is twelve: proper divisors one, two, three, four, and six sum to sixteen, so abundance is four.
Eighteen is abundant with aliquot sum twenty-one and abundance three. By contrast six is perfect because its proper divisors sum exactly to six, and ten is deficient because one plus two plus five equals eight. Perfect and deficient inputs are therefore valid responses with abundant false and abundance less than or equal to zero; they are not errors.
One has an empty proper-divisor set, so its aliquot sum is zero and it is deficient. If you need prime factors of a single integer rather than abundance classification, use a factorization tool; this page answers only the abundant-number question with the abundance amount.
How the inputs are read and how the aliquot sum stays exact
Optional leading plus signs are allowed for positive values; embedded spaces, hex prefixes, and exponential notation are rejected so a bad cell does not become a wrong flag. Negative integers and zero are rejected because abundance is defined on positive integers in this checker. The engine stays inside JavaScript safe integers, which is more than enough for classroom problems, programming contests, and most applied checks on moderately large n.
Internally the proper divisors are collected by trial division: walk d from two through the floor of the square root of n, and whenever d divides n add both d and n divided by d when those partners are distinct and neither equals n, always counting one for n greater than one. That procedure needs only a handful of modular checks for ordinary inputs and never approximates. There is no floating-point step that could round a near-integer into a false abundant claim.
Where abundance checks fit in study, research demos, and code
Students meet abundant numbers when learning perfect and deficient companions, when exploring highly composite structure, and when reading about sociable and amicable chains that begin from aliquot maps. Teachers can generate answer keys for worksheets without trusting opaque calculator apps that hide the divisor sum. Developers use the same contract to validate sample data for number-theory libraries, to gate property tests on random integer generators, or to pre-check that a seed sits in the abundant class before a simulation step.
Contest practice often needs a fast offline source of abundance answers so solutions can be checked without downloading OEIS tables. Pair it with prime factorization when you need the prime powers behind a single integer, with a coprime checker when you need pairwise gcd tests, and with an nth-prime tool when you need ranks rather than divisor sums.
What you can do with it
Homework and contest classification
Classify integers as abundant, perfect, or deficient for worksheets and contest checks by reading the abundance sign without building a full divisor list by hand.
Teaching aliquot maps
Show students how aliquot sum minus n measures abundance while they change n live in the browser at no cost.
FAQ
What does the abundant number checker cost?
It is free in your browser on this page.
What happens if n is below 1?
Abundance is defined here only for positive integers n ≥ 1.
How is abundance computed?
The number is abundant when that difference is positive.
Is the algorithm randomized?
No. It uses deterministic trial division. The same n always yields the same aliquot sum, abundance, and abundant flag.
How is this different from prime factorization?
Factorization splits one integer into prime powers. This tool classifies one integer by its proper-divisor sum and reports whether that sum exceeds n.
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/numth/abundant-number \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"n":12}'const res = await fetch("https://api.kit.forhosting.com/numth/abundant-number", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"n": 12
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/numth/abundant-number",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"n": 12
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/numth/abundant-number", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"n":12}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"n":12}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/numth/abundant-number", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"n": 12
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "numth.abundant_number",
"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
Supply a positive integer n and the tool returns the aliquot sum, the abundance amount (aliquot sum minus n), and a boolean abundant flag that is true exactly when that difference is positive. Use it free in the browser for homework, contest prep, and OEIS-style exploration, or call the API at $0.002 per successful request when you automate classification pipelines, grading scripts, or teaching demos that need reproducible abundance answers.
What abundant means and what the response contains
This checker returns the parsed n, the aliquot_sum, the signed abundance difference, and abundant true if and only if abundance is greater than zero. The contract is strict on domain: missing fields, non-integers, fractions, scientific notation, values outside the safe integer range, and any n below one fail with invalid_input and a clear message.
How the inputs are read and how the aliquot sum stays exact
The preferred field is n as a JSON integer, but decimal strings and the aliases number or value are accepted so forms, spreadsheets, and query strings can reuse one contract.
Where abundance checks fit in study, research demos, and code
On this page the work runs entirely in your browser; through the API each successful lookup costs $0.002, failed validation is not charged, and nothing is stored after the response returns. That split — free interactive exploration and a priced, identical API — matches the rest of the KIT tier-A catalog and lets you move from a classroom demo to an automated pipeline without changing the mathematical result.
Integration use cases
Deterministic test fixtures
Generate reproducible abundant and non-abundant cases for unit tests, property checks, and CI assertions without embedding static OEIS dumps.