Time and a half calculator
At 20 an hour, 40 regular hours plus 5 overtime hours paid at time and a half come to 950 gross: 800 straight time and 150 overtime at 30 an hour. Enter the wage and both hour counts. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Hourly wage
- 20
- Regular hours
- 40
- Overtime hours
- 5
- Overtime multiplier
- 1.5
- Ot hourly rate
- 30
- Regular pay
- 800
- Overtime pay
- 150
Time-and-a-half overtime is the default hourly premium in United States payroll: hours beyond the regular schedule are paid at one and a half times the regular hourly wage. A supervisor who just approved extra hours, an employee checking a timesheet, and a payroll clerk filling a gross column all need the same number — regular pay plus overtime pay. This time and a half calculator accepts three finite numbers: hourly wage, regular hours, and overtime hours. It multiplies overtime hours by one-point-five times the wage, adds straight-time pay, and returns gross pay rounded to cents.
What time-and-a-half means and how gross pay is computed
Time-and-a-half is a multiplier, not a second wage table. If the regular hourly wage is R, each overtime hour is paid at one and a half times R, while each regular hour is paid at R. Gross pay is therefore regular pay plus overtime pay: R times regular hours, plus R times 1.5 times overtime hours.
Equivalently, gross pay equals R times the sum of regular hours and one-and-a-half times overtime hours. Worked example: wage twenty dollars, forty regular hours, and five overtime hours. Regular pay is twenty times forty, which is eight hundred dollars.
The overtime hourly rate is thirty dollars, five overtime hours add one hundred fifty dollars, and gross pay is nine hundred fifty dollars. Regular pay is five hundred eighty-nine dollars. Overtime at twenty-three dollars and twenty-five cents times two hours is forty-six dollars and fifty cents, so gross pay is six hundred thirty-five dollars and fifty cents.
Money fields are rounded half-up to two decimal places, the convention used by payroll files. This landing fixes the multiplier at one-point-five because that is the search intent behind time and a half: people who type that phrase already know the premium is not double time and not a custom factor. You supply the split between regular hours and overtime hours; the calculator does not decide which hours count as overtime under the Fair Labor Standards Act, a union contract, or a state daily-overtime rule.
Zero overtime hours is valid and returns straight-time pay only. Zero regular hours with positive overtime hours is also valid for an all-overtime week. Negative hour counts are not a paycheck and fail validation instead of emitting a signed amount.
Where a time-and-a-half calculator earns its keep
People who type time and a half into a search box already know they want overtime at one-and-a-half times the hourly wage, not a general overtime tool that asks for a custom multiplier and not a double-time page. A publisher ranking for that query is serving hourly employees who just saw extra hours on a timesheet, shift supervisors who approved those hours, and payroll clerks who must fill a gross column before a pay run.
Budgeting apps and gig-work worksheets call the contract to seed a weekly cash-flow row from a stated wage and two hour buckets without storing a handwritten product. Offer-comparison notebooks pin known-good pairs — twenty dollars with forty plus five hours for a clean nine hundred fifty gross, fifteen-fifty with thirty-eight plus two for six hundred thirty-five fifty — so a library cannot silently multiply overtime by two and still call the result time-and-a-half. Failed validation does not consume balance.
Pair this capability with a separate withholding or salary converter when you need net pay or an annual figure; keep this surface focused on the gross 1.5× overtime amount that people mean when they search time and a half.
What you can do with it
Check a timesheet before payday
Enter hourly wage, regular hours, and overtime hours from a weekly timesheet to see regular pay, 1.5× overtime pay, and gross pay before deductions.
Approve extra hours on a shift
A supervisor who just signed overtime can quote the gross premium from the same 1.5× identity the payroll file will use.
FAQ
How do I calculate time-and-a-half overtime pay?
Gross pay is wage × regular hours plus wage × 1.5 × overtime hours, rounded to two decimal places.
What happens if regular hours or overtime hours are negative?
A negative hour count does not describe a paycheck and is not billed.
Is the overtime multiplier configurable?
No. This landing locks the premium at 1.5, which is what time-and-a-half means. Double time and custom multipliers belong on a different tool.
Does the calculator decide which hours are overtime?
No. You already split regular hours from overtime hours. The engine applies the 1.5× premium and adds the two lines; it does not apply FLSA or contract rules.
Can I enter a week with only overtime hours?
Yes. Enter zero regular hours and the overtime hours worked, and every hour is paid at one and a half times the wage. Zero overtime hours also works and returns straight-time pay only.
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/time-and-a-half \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"hourly_wage":20,"regular_hours":40,"overtime_hours":5}'const res = await fetch("https://api.kit.forhosting.com/fin/time-and-a-half", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"hourly_wage": 20,
"regular_hours": 40,
"overtime_hours": 5
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/fin/time-and-a-half",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"hourly_wage": 20,
"regular_hours": 40,
"overtime_hours": 5
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/fin/time-and-a-half", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"hourly_wage":20,"regular_hours":40,"overtime_hours":5}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"hourly_wage":20,"regular_hours":40,"overtime_hours":5}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/fin/time-and-a-half", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"hourly_wage": 20,
"regular_hours": 40,
"overtime_hours": 5
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "fin.time_and_a_half",
"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
Negative hour counts fail with invalid_input instead of a signed paycheck. Successful API calls are billed at $0.002; invalid input is not charged.
What time-and-a-half means and how gross pay is computed
A second example uses a fractional wage: fifteen dollars and fifty cents, thirty-eight regular hours, and two overtime hours.
Input contract, response shape, and error behaviour
A negative hourly wage is also rejected. Example: wage twenty, forty regular hours, five overtime hours yields regular pay eight hundred, overtime pay one hundred fifty, and gross pay nine hundred fifty. Failed validation is not billed. POST a JSON body with three required finite numbers. hourly_wage is the base wage per hour before the overtime premium and must be a non-negative finite number; aliases hourly_rate, rate, wage, hourly, and pay_rate are accepted so a timesheet export does not need a rename step. regular_hours is the straight-time hours paid at that wage; aliases hours, straight_hours, regular, and straight_time map to the same field. overtime_hours is the hours paid at time-and-a-half; aliases ot_hours, overtime, and ot are accepted. Each field may arrive as a JSON number or as a numeric decimal string. A missing field, an empty string, NaN, or Infinity fails with invalid_input naming the field. Prefer JSON numbers over currency-formatted strings; dollar signs, thousands separators, and accounting parentheses are not parsed. A negative regular_hours or overtime_hours value is rejected because a negative hour count does not describe a paycheck — that is the published contract for this capability. Hour counts must stay at or below one million and the wage at or below one billion so products remain finite in IEEE double precision on the Worker and in the browser. On success the body echoes the rounded wage and the hour counts, returns overtime_multiplier as the constant 1.5, ot_hourly_rate as wage times 1.5 rounded to cents, regular_pay, overtime_pay, and gross_pay as the primary total, plus a formula string restating the identity. Pricing for a successful item is a flat $0.002.
Where a time-and-a-half calculator earns its keep
Classroom consumer-math courses assign time-and-a-half worksheets and need an oracle that marks a negative hour count as invalid_input instead of emitting a signed check. Keep requests small, pin the rounded gross_pay field in tests, and you get stable time-and-a-half arithmetic for widgets, HR scripts, and edge workers without standing up a full payroll suite of your own.
Integration use cases
Pin payroll fixtures in tests
Lock known-good triples such as twenty dollars, forty hours, and five overtime hours → 950 gross so a library cannot silently switch the multiplier.
Technical questions
What does the time and a half calculator cost?
The browser tool is free. API requests use prepaid KIT balance at $0.002 per successful call; invalid input is not billed.