Australian Business Number (ABN) check
Check an eleven-digit Australian Business Number with the official tax office rule: 53 004 085 616 gives a weighted sum of 445, which divides evenly by 89, so it passes. You see the sum and remainder too. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Number
- 53004085616
- Input
- 53004085616
- Digits
- 53004085616
- Weighted sum
- 445
- Remainder
- 0
An Australian Business Number is an eleven-digit identifier issued by the Australian Business Register for GST, invoicing, and government dealings. Typing or importing an ABN with a single transposition or wrong last digit breaks supplier records, payment files, and tax reports. This Australian Business Number check implements the official Australian Taxation Office rule: subtract one from the first digit, multiply each of the eleven positions by the fixed weights ten, one, three, five, seven, nine, eleven, thirteen, fifteen, seventeen, and nineteen, sum the products, and accept the number only when that sum is divisible by eighty-nine. The response reports valid true or false, the weighted sum, and the remainder so forms can show a clear pass or fail without a network lookup.
How the ATO ABN modulo-89 check works
An Australian Business Number always has eleven digits when written without spaces. The Australian Taxation Office publishes a deterministic checksum so that most single-digit slips and many adjacent transpositions fail the test before the identifier is stored or printed on a tax invoice.
The procedure is fixed and public: take the eleven digits from left to right; subtract one from the first digit only (the remaining ten digits are left unchanged); multiply each digit by its positional weight from the official series ten, one, three, five, seven, nine, eleven, thirteen, fifteen, seventeen, nineteen; add those eleven products into a single weighted sum; divide that sum by eighty-nine and keep the remainder. The ABN is valid under the checksum if and only if the remainder is zero.
The algorithm never contacts the Australian Business Register, never looks up entity status, and never uses a clock or random source—it only proves that the digit string is well formed under the official weights. A passing check does not mean the business is still registered, that the ABN is authorised for a particular tax regime, or that the name on an invoice matches ABR records; it only means the eleven digits satisfy the modulo-eighty-nine identity.
Where an ABN check earns its keep in real workflows
Accounts-payable and vendor-onboarding teams validate eleven-digit ABNs at form submit so a single transposition does not create a phantom supplier and a GST invoice mismatch. Payroll and contractor tools walk every ABN column in a CSV export, call this capability, and quarantine rows where valid is false—catching both human edits and off-by-one bugs in generators. Finance shared-services centres use the structured remainder field in support macros: when a partner insists their ABN is correct, support can show that the remainder is not zero without opening a spreadsheet of weights.
Do not treat a passing ABN check as proof of active ABR registration or of a specific GST status; it only proves the weighted sum is divisible by eighty-nine under the official first-digit adjustment. Pair the checksum with a registry lookup when legal or tax compliance requires entity status, and keep this lightweight validator on the hot path where latency and determinism matter most.
What you can do with it
Vendor and supplier onboarding forms
Validate the eleven-digit ABN at submit time and block save when valid is false, reducing GST invoice mismatches from single-digit typos.
Marketplace and payout KYC checks
Run the modulo-89 check before enabling seller payouts so freelancers and merchants cannot store a structurally invalid Australian Business Number.
ERP and CSV data-quality audits
Batch-check every ABN column in vendor master files and quarantine rows whose weighted sum is not divisible by eighty-nine.
FAQ
How does the Australian Business Number check work?
Subtract one from the first of eleven digits, multiply by the ATO weights 10,1,3,5,7,9,11,13,15,17,19, sum the products, and accept the ABN only when that sum modulo 89 equals zero.
Does a valid checksum mean the business is registered?
No. This tool only proves the eleven digits satisfy the ATO modulo-89 rule. Active registration, entity name, and GST status require an Australian Business Register or government lookup.
What does the Australian ABN check cost?
The browser tool is free and runs locally.
Can I paste an ABN with spaces or hyphens?
Yes. Spaces and hyphens are stripped, so the usual display form 53 004 085 616 is read as eleven digits. Letters, decimal points, slashes and other punctuation are rejected rather than quietly removed, and the digits must come to exactly eleven.
Which typing mistakes does the ABN checksum catch?
Most single-digit slips and many swaps of two neighbouring digits fail the test, so a mistyped ABN is stopped before it reaches a supplier record, a payment file or a tax invoice. It catches most common errors, not every possible one.
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/enc/abn-australia \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"number":"53004085616"}'const res = await fetch("https://api.kit.forhosting.com/enc/abn-australia", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"number": "53004085616"
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/enc/abn-australia",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"number": "53004085616"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/enc/abn-australia", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"number":"53004085616"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"number":"53004085616"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/enc/abn-australia", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"number": "53004085616"
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "enc.abn_australia",
"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
Wrong length and non-numeric input fail with invalid_input instead of a silent false. The same pure arithmetic powers the free browser tool and the API path at $0.002 per successful call.
Input contract, response shape, and error behaviour
Digits zero through nine are required; optional spaces and hyphens are stripped so common display forms such as fifty-three space zero-zero-four space zero-eight-five space six-one-six are accepted and normalised to eleven contiguous digits. Empty strings, missing number, floats, and negative numbers fail before any weighted sum is computed and are not billed. POST a JSON body with a required number field holding the ABN. Letters, decimal points, slashes, and other punctuation are rejected as non-numeric input with invalid_input so a half-cleaned value never reaches storage. After stripping, the engine requires exactly eleven digits: shorter or longer strings fail with a length error that names how many digits you sent. On success the body echoes input and digits as the normalised eleven-digit string, valid as a boolean, weighted_sum as the integer sum after the first-digit adjustment, remainder as that sum modulo eighty-nine, length eleven, algorithm abn-mod89, and a short formula string restating the rule for display next to the result. When the string is eleven digits but fails the checksum, the call still succeeds with valid false and a non-zero remainder—so data-quality jobs can quarantine rows without treating a mistyped ABN as a transport error. Alias keys abn, digits, text, value, n, and code map to the same payload field so integrations that already speak abn do not need a rename. Prefer this path when you only need the ATO checksum; use an ABR or government registry API when you need active registration status. Because the path is pure parse with no clock or network, the same JSON body always yields the same JSON result on the free browser tool and on the API at $0.002 per successful request.
Where an ABN check earns its keep in real workflows
Marketplace and freelancing platforms recompute the modulo-eighty-nine remainder client-side or via API and block payout setup when valid is false, showing a friendly correction instead of a silent save.
Technical questions
What input format does the ABN validator accept?
Send number (or alias abn) with digits 0-9. Optional spaces and hyphens are stripped. After normalisation the string must be exactly eleven digits; letters and other symbols fail with invalid_input.
What does a successful response look like?
You receive digits, valid (true or false), weighted_sum, remainder (sum % 89), length 11, algorithm abn-mod89, and a short formula string. Checksum failures return valid false without throwing.