Proper divisors list
Lists every positive divisor of n except n itself, in ascending order with a count: for 12 you get 1, 2, 3, 4 and 6, five in all. Use it for perfect-number checks, homework or splitting a size evenly. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- N
- 12
- Proper divisors
- 1, 2, 3, 4, 6
- Quantity
- 5
Proper divisors of a positive integer n are the positive divisors of n that do not include n itself. They appear in aliquot-sum definitions, perfect-number tests, abundance and deficiency classification, and countless classroom exercises that ask for the list rather than only the total. This capability takes one positive integer n and returns the ordered list of proper divisors together with how many there are, so you can check homework, feed a grading script, or document the proper-divisor structure of a configuration size without walking candidates by hand.
What proper divisors are and why the list matters
A positive divisor of an integer n is any positive integer d such that n divides evenly by d with no remainder. The full divisor set always includes one and n. Proper divisors, in the convention used by this capability and by classical aliquot-sum work, are exactly those positive divisors that are strictly smaller than n.
For twelve the full divisors are one, two, three, four, six, and twelve; the proper divisors are one, two, three, four, and six. For a prime p the only proper divisor is one. For one the proper-divisor set is empty because nothing is both a positive divisor of one and strictly less than one.
Textbooks and contest problems often ask for that set explicitly, not only for the aliquot sum s(n) equal to the total of those values. Having the ordered list lets a student verify each factor, lets a teacher mark partial credit when a middle factor is missing, and lets a pipeline assert that a batch size or page count splits only along true proper factors. Automating the enumeration keeps the result complete, ascending, and ready for the next step without re-deriving a square-root walk in every client.
How the capability computes the answer
The engine walks candidate divisors from one up through the integer square root of n. Whenever a candidate divides n evenly it records that candidate and, when the complementary quotient is strictly less than n and different from the candidate, records the quotient as well. Perfect-square middle factors are recorded once.
After the scan finishes, complementary factors are reversed and concatenated so the full proper-divisor list is strictly ascending without a separate full-array sort. For n equal to one the array is empty and count is zero, matching the empty proper-divisor set. Sibling landings cover the full divisor list including n, the aliquot sum with perfect or abundant labels, and a dedicated perfect-number yes-or-no check; this page targets people who specifically want the proper-divisors list and count.
Where to use it and what it costs
Typical placements include validating student answers that list proper divisors for a given n, preparing aliquot-sequence steps that need the set before summing, documenting proper factors of configuration sizes such as batch counts, and contrasting proper-divisor lists of primes against composites in teaching demos. The browser path runs locally and needs no account. Keep n inside the documented bounds so the square-root walk stays predictable, and treat the returned count as a first-class field rather than re-deriving it from the array in client code that might drift from this contract.
When you only need the sum or a perfect-membership flag, prefer the dedicated aliquot-sum or perfect-number tools; when you need every divisor including n, use the full divisor-list landing. For proper-divisors-list search intent, this capability is the direct answer: the ordered proper set plus how many members it has, every time.
What you can do with it
Homework proper-divisor lists
Check a student’s ordered proper divisors and count for a given n against one canonical response instead of grading a hand-written factor walk.
Aliquot and abundance prep
Obtain the proper-divisor set before summing or classifying deficient, perfect, or abundant numbers in recreational number-theory pipelines.
Teaching primes versus composites
Show that every prime has exactly one proper divisor (one) while composite classroom examples fan out into longer ascending lists.
FAQ
What happens if n is zero or negative?
Only positive integers starting at 1 are accepted.
How is a proper divisor different from a divisor?
The full divisor list always includes 1 and the number itself; proper divisors leave the number out. For 12 the divisors are 1, 2, 3, 4, 6 and 12, while the proper ones stop at 6.
What are the proper divisors of a prime number?
Only 1. A prime is divisible just by 1 and by itself, and the number itself is never counted, so the list has a single entry and the count is 1.
Why does 1 have no proper divisors?
No positive whole number is both a divisor of 1 and smaller than 1. The list is therefore empty and the count is 0, which matches the usual definition in textbooks.
What is the largest number I can enter?
Any whole number from 1 up to one trillion. Zero, negative values, decimals and anything above that ceiling are rejected with a clear message instead of a partial 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/numth/proper-divisors \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"n":12}'const res = await fetch("https://api.kit.forhosting.com/numth/proper-divisors", {
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/proper-divisors",
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/proper-divisors", 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/proper-divisors", 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.proper_divisors",
"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
Failed validation is never charged; successful API calls use the published $0.002 base price per request.
How the capability computes the answer
You send a JSON body with a single required field n, a positive integer at least one and at most one trillion. The response reports n itself, the ordered array proper_divisors, and count as the length of that array. Invalid input—missing n, a non-integer, zero, a negative value, a boolean, or a number above the published ceiling—fails with invalid_input and is never charged. There is no randomness, no clock dependency, and no network call; two identical requests always produce the same JSON.
Where to use it and what it costs
Use the free browser tool when you want a quick check for a single value, or call the API when a script, gradebook, or data job must resolve many integers the same way every time. API usage draws from prepaid KIT balance at the published $0.002 base price per successful request; failed validation does not consume balance.
Technical questions
How do I list the proper divisors of a number with this API?
POST a JSON body with the positive integer field n. The response includes proper_divisors in ascending order and count.
Does the list include n itself?
No. Proper divisors exclude n. For primes the only proper divisor is 1; for n = 1 the list is empty.
Is the proper divisors list tool free?
The browser widget is free and runs locally. API calls use prepaid KIT balance at the published $0.002 base price; invalid input is not charged.
Is the result always the same for the same n?
Yes. The algorithm is pure trial division with no randomness or timestamps, so identical inputs produce identical JSON.