Credit utilization calculator
Add up your revolving balances and your credit limits, and see what share is in use: 2000 owed on 10000 of limits is 20% utilization, with 8000 still available. No need to enter each card one by one. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Total balance
- 2,000
- Total credit limit
- 10,000
- Utilization ratio
- 0.2
- Utilization percent
- 20
- Available credit
- 8,000
- Over limit amount
- 0
Credit utilization is the share of revolving credit already in use: total outstanding card and line balances divided by total credit limits, expressed as a percent. Lenders and FICO-style scoring models treat that percentage as a large slice of the amounts-owed factor, which is why people look up a credit utilization calculator before they apply for a mortgage or try to lift a mid-range score. This tool takes two already-summed numbers — total balances and total credit limits — divides them, multiplies by one hundred, and returns utilization as a percentage plus remaining available credit.
What credit utilization means and how the two totals become a percent
Credit utilization is the fraction of revolving credit already drawn: take the combined outstanding balances on credit cards, store cards, and other revolving lines, then divide by the combined credit limits on those same accounts. You already know the totals from a monthly statement, a credit-report summary, or a spreadsheet column, and you want the percent without re-entering each card as a row.
Scoring bureaus treat this ratio as a large part of the amounts-owed factor, so a wallet that looks fine as a pile of dollar balances can still look stretched once it is expressed as a percent of available limits. The identity is not the same as a debt-to-income ratio, a snowball payoff plan, a credit-card payoff schedule, or a Luhn check on a card number: people who type credit utilization calculator after summing their cards want the revolving-limit picture in one step.
Unused limits still belong in the denominator you send. Installment loans, mortgages, and auto notes are not revolving credit and do not belong in these totals. A total credit limit of zero cannot define a rate, so the calculator rejects it instead of dividing by zero.
What you can do with it
Quick percent from statement totals
Paste combined revolving balances and combined credit limits from a monthly statement or credit-report summary and read utilization as a percent plus remaining available credit.
Pre-application check before a mortgage pull
Convert two already-summed revolving totals into a utilization percent so you can see whether the wallet sits under a 30 percent or 10 percent guideline this cycle.
FAQ
How do I calculate my credit utilization?
Divide the combined balances on your cards and revolving lines by their combined credit limits and multiply by one hundred. A total balance of 2000 on total limits of 10000 is 20% utilization.
Should I include cards I don't use?
Yes. An unused card still adds its limit to the total, which lowers your percentage. Even a card with a zero balance helps, so closing it can raise utilization overnight without any new borrowing.
Do loans and mortgages count toward credit utilization?
No. Installment loans, mortgages and car loans are not revolving credit, so leave them out of both totals. Only cards, store cards and other revolving lines belong here.
What happens if I'm over my credit limit?
The percentage goes past one hundred, the available credit shows as zero, and the amount above the limit is reported separately so you can see how far over you are.
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/fin/credit-utilization \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"total_balance":2000,"total_credit_limit":10000}'const res = await fetch("https://api.kit.forhosting.com/fin/credit-utilization", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"total_balance": 2000,
"total_credit_limit": 10000
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/fin/credit-utilization",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"total_balance": 2000,
"total_credit_limit": 10000
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/fin/credit-utilization", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"total_balance":2000,"total_credit_limit":10000}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"total_balance":2000,"total_credit_limit":10000}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/fin/credit-utilization", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"total_balance": 2000,
"total_credit_limit": 10000
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "fin.credit_utilization",
"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
A total credit limit of zero is rejected with invalid_input and is not billed, because dividing by zero cannot define a utilization rate.
What credit utilization means and how the two totals become a percent
In symbols, utilization_ratio equals total_balance divided by total_credit_limit, and utilization_percent is that ratio times one hundred. This calculator is the two-number form of that identity. An unused card with a zero balance and a four-thousand limit still enlarges total_credit_limit and lowers the overall percent; closing that card later can raise utilization overnight even though you borrowed nothing new. A worked check is a combined balance of two thousand on a combined limit of six thousand: the ratio is one third, and utilization_percent is about 33.33. That sits just above the common 30 percent guideline that many counselors cite before a mortgage pull. When the combined balance exceeds the combined limit the wallet is over-limit, the percent goes past one hundred, available_credit is zero, and over_limit_amount records the excess.
Input contract, response shape, and error behaviour
POST a JSON body with two required finite numbers. total_balance is the combined outstanding revolving balance in one currency unit; aliases balance, balances, total_balances, and outstanding map to the same field so a statement extract can keep its column names. total_credit_limit is the combined revolving credit limit in that same currency; aliases credit_limit, limit, total_limit, and creditLimit are accepted. Each numeric field may arrive as a JSON number or a numeric string. Missing fields, empty strings, and non-finite values fail with invalid_input naming the field. total_balance must be greater than or equal to zero: a zero balance is a legitimate unused-credit case and returns utilization_percent of zero rather than an error. A negative balance is rejected. total_credit_limit must be strictly greater than zero. A balance larger than the limit is allowed: the wallet is over-limit, utilization_percent exceeds one hundred, over_limit is true, available_credit is zero, and over_limit_amount records the surplus instead of clamping the percent. On success the body echoes the two totals rounded half-up to two decimal places, then reports utilization_ratio rounded to six places, utilization_percent rounded to two places, available_credit, over_limit_amount, the over_limit boolean, and a formula string restating the identity. Example: two thousand of combined balances on a ten-thousand combined limit yields a utilization of twenty percent, eight thousand of available credit, and over_limit false. Pair the JSON with your own list of which accounts you summed — this endpoint divides the two numbers you send; it does not pull a bureau file, age a score, or reconstruct per-card rows.
Where a credit utilization calculator earns its keep
Pair it with your own bureau extract when the question is what the bureaus already see, and use this calculator when the question is what two known revolving totals imply right now. Credit counselors and nonprofit coaches use the two-number endpoint when a client already has statement totals in hand and only wants the percent, remaining room, and whether the wallet is over-limit, without typing every card. Exam-prep and classroom units need a deterministic oracle that treats a zero limit as invalid_input rather than a divide-by-zero, allows over-limit percents above one hundred, and returns both the ratio and the percent. Keep requests small and pin utilization_percent plus available_credit in tests. This tool does not pull a credit report, does not age a FICO-style score, and does not model authorized-user tradelines, charge-offs, or the difference between reported statement balances and today's live balance. Keep total_credit_limit strictly positive, send both numbers in one currency, and you get a reproducible utilization percent for landing pages, LMS plugins, and edge workers without standing up a per-card engine of your own.
Integration use cases
Batch quotes and CI fixtures
Pin utilization_percent from known totals in underwriting extracts and tests without re-implementing the ratio in every service.
Technical questions
How do I calculate credit utilization from total balances and limits?
Send total_balance (combined revolving balances, >= 0) and total_credit_limit (combined limits, > 0). The API returns utilization_percent = (total_balance / total_credit_limit) × 100, plus available credit and an over-limit flag.
What happens if the total credit limit is zero?
The task fails with invalid_input. Credit utilization is undefined when the total credit limit is zero, so the request is not billed instead of dividing by zero.
Can the balance be larger than the credit limit?
Yes. Over-limit wallets are allowed. utilization_percent goes past 100, over_limit is true, available_credit is 0, and over_limit_amount records the excess.
Does a zero balance count as an error?
No. A zero total_balance on a positive limit is unused revolving credit and returns utilization_percent of 0. Negative balances are rejected.
What does the credit utilization calculator cost?
The browser tool is free. API requests use prepaid KIT balance at $0.002 per successful call; invalid input is not billed.