Billable hours calculator
Forty hours worked at 150 an hour with two hours written off gives 38 billable hours and an invoice total of 5,700. Enter your timesheet figures and get the amount to bill without rebuilding the math in a spreadsheet. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Hours worked
- 40
- Hourly rate
- 150
- Non billable hours
- 2
- Billable hours
- 38
- Invoice total
- 5,700
- Amount
- 5,700
Freelancers, consultants, agencies, and in-house timekeepers need a single invoice total from hours worked, an hourly rate, and any hours that must stay off the bill. This billable hours calculator subtracts non-billable time from hours worked, multiplies the remainder by the hourly rate, and returns the invoice total you can drop into a draft, a timesheet review, or a billing script. Non-billable hours default to zero when omitted. A negative hourly rate is rejected as invalid input rather than producing a signed invoice.
Where a billable hours calculator earns its keep
People who type billable hours into a search box already know they are pricing time, not converting a salary and not computing overtime premium. They want the invoice total from hours on the clock, a rate, and any write-off, without rebuilding the same subtraction and multiplication in a spreadsheet cell that drifts when someone forgets to lock the write-off. Independent consultants draft weekly invoices from a timesheet and need a number they can paste into a statement.
In-house legal, design, and professional-services teams write off training or goodwill and still want a deterministic invoice total for the remainder. Classroom and bookkeeping courses that teach time-and-materials billing need an oracle that rejects a negative hourly rate instead of silently emitting a signed total a grader might treat as a credit. Failed validation does not consume balance.
Pair this capability with a separate overtime or tax tool when you need those layers; keep this surface focused on the billable-hours invoice total that people mean when they search that phrase.
What you can do with it
Weekly freelance invoice from a timesheet
Enter hours worked, your hourly rate, and any write-off hours to publish the invoice total without rebuilding the subtraction in a spreadsheet.
Agency utilization before the client bill
Subtract non-billable admin or training from recorded hours, then multiply by the engagement rate to lock the amount finance will invoice.
FAQ
How do I calculate billable hours and the invoice total?
Billable hours equal hours worked minus non-billable hours. Invoice total equals that remainder times the hourly rate. Example: (40 − 2) × 150 = 5700.
What happens if the hourly rate is negative?
A negative hourly rate is not a discount and is not billed; fix the rate and resubmit.
What counts as non-billable hours?
Any time you record but choose not to invoice: write-offs, training, internal admin and goodwill. It is subtracted from the hours worked, and if you leave it out, it counts as zero.
How do I show a pro bono or complimentary line?
Enter a rate of zero. The invoice total comes out as zero while the hours stay on record, which is how a no-charge line is shown without inventing a different formula.
Can I enter quarter hours?
Yes. Hours can be fractional, so seven and a quarter hours is a valid timesheet entry, and the invoice total is rounded to two decimals so it matches an ordinary currency amount.
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/billable-hours \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"hours_worked":40,"hourly_rate":150}'const res = await fetch("https://api.kit.forhosting.com/fin/billable-hours", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"hours_worked": 40,
"hourly_rate": 150
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/fin/billable-hours",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"hours_worked": 40,
"hourly_rate": 150
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/fin/billable-hours", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"hours_worked":40,"hourly_rate":150}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"hours_worked":40,"hourly_rate":150}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/fin/billable-hours", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"hours_worked": 40,
"hourly_rate": 150
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "fin.billable_hours",
"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.
Limits
max_hours | 1000000 |
max_rate | 1000000000 |
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
Successful calls are billed at $0.002; invalid input is not charged.
What billable hours are and how the invoice total is formed
Billable hours are the hours a client actually pays for: time on the engagement minus write-offs, training, internal admin, and goodwill that you choose not to invoice. Example: forty hours worked at one hundred fifty per hour with two hours written off is thirty-eight billable hours and an invoice total of five thousand seven hundred. A zero hourly rate is allowed and yields an invoice of zero, which is how a complimentary or pro-bono line is represented without inventing a different formula. Non-billable hours cannot exceed hours worked, because that would invent negative billable time. Hours may be fractional (seven and a quarter is a valid quarter-hour timesheet), and money fields are rounded half-up to two decimal places so the invoice total matches ordinary currency. The identity is one subtraction and one multiplication. hours_worked is everything recorded on the timesheet or engagement clock, including time you may later mark non-billable. non_billable_hours is the slice that must stay off the invoice. Subtract that slice from hours worked and you have billable_hours. Multiply billable hours by hourly_rate and you have invoice_total, the amount this calculator returns as the primary result and again as amount so a dashboard can bind either key. When non_billable_hours is omitted it is treated as zero, so a clean week of eight hours at seventy-five per hour invoices six hundred with nothing written off. A negative hourly rate is not a discount and is not a credit memo: it is rejected as invalid_input so a typo cannot emit a signed invoice that a downstream ledger would post as a refund. The formula string in the response restates invoice_total equals hours_worked minus non_billable_hours, times hourly_rate, so a reviewer can print the identity next to the number without reconstructing it.
Input contract, response shape, and error behaviour
Example: hours worked seven point two five, hourly rate eighty-five point five, non-billable zero point two five yields seven billable hours and an invoice total of five hundred ninety-eight point five. Prefer bare numbers over formatted strings; currency marks, thousands separators, and trailing unit labels are not parsed. Pair the result with your own tax or document step if you need a filed invoice. POST a JSON body with two required finite numbers and one optional finite number, all in the same currency and the same billing window. hours_worked is the total recorded time and must be greater than or equal to zero; aliases hours, total_hours, time_worked, and worked_hours are accepted so a timesheet export does not need a rename step. hourly_rate is the billable rate per hour and must be greater than or equal to zero; aliases rate, rate_per_hour, bill_rate, and hourly are accepted. A negative hourly rate fails with invalid_input naming hourly_rate and is not billed. non_billable_hours is optional, defaults to zero, must be greater than or equal to zero, and must not exceed hours_worked; aliases nonbillable_hours, unpaid_hours, write_off_hours, and non_billable are accepted. Each field may arrive as a JSON number or as a numeric string that matches a strict finite decimal pattern. Missing required fields, empty strings, non-finite values, hours above one million, or a rate above one billion fail with invalid_input naming the field. On success the body echoes rounded hours_worked, hourly_rate, and non_billable_hours, returns billable_hours as their difference, returns invoice_total and amount as the same half-up two-decimal product, and includes a formula string you can print next to the numbers. This endpoint does not apply sales tax, retainers, overtime multipliers, or currency conversion, and it does not emit a PDF invoice. Pricing for a successful item is a flat $0.002.
Where a billable hours calculator earns its keep
Agencies review utilization before they send a client a bill and need the same identity a finance script will later call over the API. Keep requests small, pin invoice_total and billable_hours in tests, and you get a reproducible invoice amount for timesheet reviews, billing scripts, and lightweight practice-management notebooks without standing up a full invoicing system.
Integration use cases
Bookkeeping and time-and-materials oracles
Students and scripts compute invoice_total = (hours_worked − non_billable_hours) × hourly_rate against a deterministic result that rejects a negative rate.
Technical questions
Are non-billable hours required?
No. non_billable_hours is optional and defaults to zero, so a clean timesheet of hours worked times the hourly rate is a valid invoice.
Can non-billable hours exceed hours worked?
No. That would invent negative billable time. The calculator rejects the request with invalid_input and does not emit a signed invoice.
What does the billable hours calculator cost?
The browser tool is free. API requests use prepaid KIT balance at $0.002 per successful call; invalid input is not billed.