Debt-to-equity calculator
Get the classic leverage multiple in one step: 200000 of total liabilities on 100000 of shareholders' equity is a debt-to-equity ratio of 2, meaning two of liabilities for every one of book equity. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Total liabilities
- 200,000
- Shareholders equity
- 100,000
- Debt to equity
- 2
The debt-to-equity ratio is the classic leverage score for a company: total liabilities divided by shareholders' equity. Analysts, lenders, CFOs, and credit desks read that single multiple before they open a full balance sheet or a covenant model. A result of two means the firm has two dollars of liabilities for every dollar of book equity; a result of one-half means equity is twice the liabilities. This debt-to-equity calculator takes two numbers in the same currency — total liabilities and shareholders' equity — divides them, and returns the ratio with the formula shown beside the result.
How debt-to-equity turns total liabilities and book equity into one leverage multiple
The debt-to-equity ratio of a company is total liabilities divided by shareholders' equity. Total liabilities is the sum of every claim that is not equity — accounts payable, accrued expenses, short-term notes, the current portion of long-term debt, bonds, leases, deferred tax, and the rest of the right-hand side of the balance sheet except book equity.
Two hundred thousand of liabilities on one hundred thousand of equity is two; one hundred fifty thousand of liabilities on two hundred thousand of equity is zero point seven five; a firm with no liabilities on fifty thousand of equity is zero. The result is a multiple, not a percent: two means two-to-one, not two hundred percent. That is the convention credit memos, screening tables, and textbook problems use when they quote D/E.
Zero liabilities is a legitimate outcome and returns a ratio of zero rather than an error: the book is unlevered on the date you measured. Negative equity is also legitimate — accumulated losses can wipe out paid-in capital — and the ratio comes back negative, which is the honest signal rather than a silent absolute value. What is not legitimate is zero equity, because dividing by a zero book value does not produce a leverage multiple.
You supply both numbers in one currency; the calculator divides them and rounds the ratio half-up to six decimal places so goldens compare byte-for-byte across runtimes. This is an accounting debt-to-equity ratio from two published balance-sheet totals, not a debt-service coverage ratio, not a combined loan-to-value, not a total-debt rollup, and not a weighted-average cost of capital.
Where a debt-to-equity calculator earns its keep
Credit analysts use a debt-to-equity calculator to turn last period's published total liabilities and book equity into one comparable leverage multiple before they walk a credit memo or a covenant checklist. CFOs and board packs drop both totals from the statement of financial position and compare the accounting D/E with a debt-service coverage case rather than treating either ratio as a substitute.
This is a different search and a different job from total debt, from debt-service coverage, from combined loan-to-value, from credit utilization, and from negative-equity roll-in: those tools add liability buckets, price income against loan payments, stack liens against an appraisal, compare revolving balances with credit lines, or fold underwater equity into a new loan. Debt-to-equity prices book leverage in one multiple. Failed validation does not consume balance.
What you can do with it
Credit memo before the committee
Divide last period's published total liabilities by book equity into one D/E multiple before you walk covenants, peers, and the leverage path.
Board pack and year-end close
Pin an accounting D/E next to the prior-year page and the DSCR case so the pack shares one book-leverage score.
FAQ
How is the debt-to-equity ratio calculated?
The result is a multiple, not a percent: two hundred thousand over one hundred thousand comes back as 2, not 200. The ratio is rounded half-up to six decimal places.
Can total liabilities be zero, and can equity be negative?
Yes. An unlevered book prints a zero ratio. Accumulated losses can print negative equity, and the ratio follows that sign. Only a zero or non-finite equity, or a non-finite liability figure, is rejected.
Is this total liabilities or interest-bearing debt only?
This calculator divides the two numbers you send.
Is a debt-to-equity ratio of 2 the same as 200%?
The result is a multiple, not a percent: 2 means two-to-one, liabilities twice the size of equity. That is how credit memos, screening tables and textbook problems quote it.
What does a debt-to-equity ratio below one mean?
Liabilities are smaller than equity. A ratio of one-half, for example, means equity is twice the liabilities, and a company with no liabilities at all comes out at zero.
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/debt-to-equity \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"total_liabilities":200000,"shareholders_equity":100000}'const res = await fetch("https://api.kit.forhosting.com/fin/debt-to-equity", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"total_liabilities": 200000,
"shareholders_equity": 100000
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/fin/debt-to-equity",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"total_liabilities": 200000,
"shareholders_equity": 100000
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/fin/debt-to-equity", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"total_liabilities":200000,"shareholders_equity":100000}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"total_liabilities":200000,"shareholders_equity":100000}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/fin/debt-to-equity", 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_liabilities": 200000,
"shareholders_equity": 100000
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "fin.debt_to_equity",
"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
Equity that is zero, missing, or not a finite number is rejected with invalid_input and is not billed, because a zero book value cannot define a leverage multiple.
How debt-to-equity turns total liabilities and book equity into one leverage multiple
Shareholders' equity is assets minus those liabilities: paid-in capital, retained earnings, treasury stock, and accumulated other comprehensive income, taken as the book figure on the statement of financial position. The identity this calculator uses is debt_to_equity equals total_liabilities divided by shareholders_equity. This endpoint does not pick interest-bearing debt out of total liabilities, does not mark assets to market, does not convert currencies, and does not reconstruct a fully diluted share count.
Input contract, response shape, and error behaviour
Total liabilities may be zero or negative: a debt-free book against positive equity produces a ratio of zero; a rare credit balance on the liability side produces a negative ratio, which is the honest going-in result rather than a clamped multiple. Example: two hundred thousand of total liabilities and one hundred thousand of shareholders' equity yield a debt-to-equity ratio of two. POST a JSON body with two required finite numbers. total_liabilities is the sum of current and non-current liabilities in one currency unit; aliases liabilities, total_debt, and debt map to the same field so a spreadsheet can keep its column names. shareholders_equity is book equity in that same currency; aliases equity, stockholders_equity, and book_equity 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. On success the body echoes total_liabilities and shareholders_equity, then reports debt_to_equity as the rounded multiple, plus a formula string restating the identity. Pair the JSON with your own note for which liability definition matches the equity you chose — total liabilities, interest-bearing debt only, or a covenant-adjusted figure — because this endpoint divides the two numbers you send; it does not rebuild the balance sheet, strip operating liabilities, or convert currencies. Keep shareholders_equity non-zero and finite, pin the rounded multiple in tests, and you get a reproducible D/E for filings, LMS plugins, and edge workers without standing up a credit engine of your own.
Where a debt-to-equity calculator earns its keep
Equity researchers re-run the same two fields when a year closes or a recapitalization moves either side of the balance sheet, then pin debt_to_equity in a screening table so every peer conversation starts from one number. Keep shareholders_equity strictly non-zero, pin the rounded multiple in tests, and you get a reproducible debt-to-equity ratio for teasers, LMS plugins, and edge workers without standing up a leverage engine of your own.
Integration use cases
Peer screen after a recapitalization
Re-price a name when a year closes or a recap moves either side of the balance sheet: same calculator, new inputs, one shared debt_to_equity.
Technical questions
What happens if shareholders' equity is zero?
The task fails with invalid_input. debt-to-equity is undefined when book equity is zero, so shareholders_equity (aliases equity, stockholders_equity, book_equity) must be a finite non-zero number. That failure is not billed.
What does the debt-to-equity calculator cost?
The browser tool is free. API requests use prepaid KIT balance at $0.002 per successful call; invalid input is not billed.