Weekly pay calculator
Your weekly gross for 40 regular hours and 5 overtime hours at 20 an hour is 950, before tax or benefits come out. Enter the hours as they are split on the timesheet and get the line for this week's paycheck. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Hourly rate
- 20
- Regular hours
- 40
- Overtime hours
- 5
- Overtime multiplier
- 1.5
- Overtime rate
- 30
- Regular pay
- 800
- Overtime pay
- 150
Weekly pay is the gross amount an hourly employee earns in a single workweek before tax, benefits, or garnishments. It is the sum of regular hours paid at the stated hourly rate and overtime hours paid at time-and-a-half. This weekly pay calculator takes those three figures, computes regular pay and overtime pay separately, and returns the weekly gross you can drop onto a timesheet, offer letter, or payroll worksheet.
What weekly pay means: regular hours plus overtime at time-and-a-half
Weekly pay for an hourly worker is a weekly gross, not an annual salary and not a take-home figure after tax. The standard overtime premium used on this page is time-and-a-half: every overtime hour is paid at one and one-half times the regular hourly rate, while regular hours stay at the base rate. The three quantities you already know — the hourly rate, how many hours were straight time, and how many hours were overtime — are enough to compute the week.
Unlike an overtime-pay tool that asks for a custom multiplier, the premium here is fixed at time-and-a-half so the search weekly pay maps to the default most hourly jobs use. Unlike an hourly-to-salary converter, nothing is annualized by fifty-two weeks. Zero regular hours with overtime hours only is also accepted, because the contract is arithmetic, not a judgment of how a timesheet should have been coded.
Negative amounts are not weeks; they are rejected.
Together the two hour fields must not exceed one hundred sixty-eight, the length of a calendar week. Zero is allowed and can yield a zero week. A missing field also fails.
Money fields are rounded to two decimal places; hour fields use six. Optional output keys are omitted rather than set to null.
Where a weekly pay calculator earns its keep
Payroll clerks and small employers use a weekly pay calculator when a timesheet already splits regular and overtime hours and they need the gross dollar line before a paycheck is cut, without opening a full HR suite or choosing a custom overtime multiplier. Hourly candidates check an offer that quotes a rate plus typical overtime so the weekly figure is honest, not an annualized salary that hides how overtime was assumed.
Shift leads in warehouses, restaurants, and healthcare compare a forty-hour week against a forty-plus-overtime week on the same rate without mixing in a state daily-overtime schedule they are not under. Teachers and bookkeeping classrooms generate answer keys for time-and-a-half weekly pay instead of trusting opaque apps that apply a multiplier to hours the student already classified, or that annualize by fifty-two without being asked.
What you can do with it
Timesheets already split into regular and overtime
Turn a known hourly rate plus classified regular and overtime hours into a weekly gross at time-and-a-half before the paycheck is cut.
Offer letters that quote overtime weeks
Show a candidate the weekly figure for a typical forty-hour week plus overtime hours, without converting the rate into an annual salary.
FAQ
What happens if an input is negative or not a number?
Every field must be a non-negative finite number. Missing, infinite, and negative values are rejected, and failed validation is not billed.
Can I choose a different overtime multiplier than time-and-a-half?
No. This weekly pay calculator always uses 1.5×. For a custom overtime multiplier use a general overtime-pay tool; this page is the default weekly paycheck under time-and-a-half.
Does it turn my weekly pay into a yearly salary?
No. The result is one week's gross and nothing is multiplied by fifty-two. Use it for a timesheet or for an offer that quotes a typical week, not for an annual figure.
Does it decide which hours count as overtime?
No. You enter regular and overtime hours already split, and they are paid as entered. It does not move hours beyond forty into overtime the way some state calculators do.
Is there a limit on the hours I can enter?
Yes. Regular and overtime hours together cannot exceed 168, the number of hours in a calendar week. Zero is allowed for either of them.
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/weekly-pay \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"hourly_rate":20,"regular_hours":40,"overtime_hours":5}'const res = await fetch("https://api.kit.forhosting.com/fin/weekly-pay", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"hourly_rate": 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/weekly-pay",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"hourly_rate": 20,
"regular_hours": 40,
"overtime_hours": 5
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/fin/weekly-pay", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"hourly_rate":20,"regular_hours":40,"overtime_hours":5}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"hourly_rate":20,"regular_hours":40,"overtime_hours":5}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/fin/weekly-pay", 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_rate": 20,
"regular_hours": 40,
"overtime_hours": 5
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "fin.weekly_pay",
"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_hourly_rate | 1000000000 |
max_hours | 168 |
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
Any value that is missing, not finite, or negative is rejected with invalid_input rather than a silent negative paycheck. The same pure arithmetic powers the free browser tool and the API, so a manual check and a script never disagree on the weekly total.
What weekly pay means: regular hours plus overtime at time-and-a-half
Multiply hourly_rate by regular_hours for the regular line. Multiply hourly_rate by one and one-half by overtime_hours for the overtime line. Add those two lines to obtain weekly_pay. Unlike a Florida-style calculator that infers overtime as hours beyond forty in a workweek, this endpoint does not reclassify a lump of total hours; you supply regular_hours and overtime_hours as already split. Zero overtime is a valid week: overtime_pay is zero and weekly_pay equals regular pay.
Input contract, response shape, and rejected non-negative failures
POST a JSON body with three required finite numbers. hourly_rate is the regular wage before the overtime premium; aliases rate, wage, hourly, pay_rate, and hourly_wage are accepted so payroll forms can reuse the same contract. regular_hours is the straight-time hours in the workweek, at most one hundred sixty-eight; aliases hours, weekly_hours, straight_hours, regular, and week_hours map to the same value. overtime_hours is the hours paid at time-and-a-half in that same week, also at most one hundred sixty-eight; aliases ot_hours, overtime, and ot are accepted. Numeric strings that parse as finite decimals are accepted; empty strings, objects, NaN, and Infinity fail with invalid_input naming the field. If any of the three values is negative the request is rejected with a message that the field must be a non-negative number — that is the hard contract of this calculator, and those failures are not billed. On success the body echoes hourly_rate, regular_hours, and overtime_hours, reports overtime_multiplier always one point five, overtime_rate as the time-and-a-half hourly figure, regular_pay, overtime_pay, weekly_pay as the gross, and a formula string. Example: hourly_rate twenty, regular_hours forty, and overtime_hours five produces regular_pay of eight hundred, overtime_pay of one hundred fifty, and weekly_pay of nine hundred fifty, because five times twenty times one and one-half is one hundred fifty.
Where a weekly pay calculator earns its keep
Staffing tools put weekly_pay next to regular_pay and overtime_pay so a coordinator sees the gross, not a wall of raw hours. On this page the work runs entirely in the browser; through the API each successful lookup costs $0.002, failed validation is not charged, and nothing is stored after the response returns. Pair the free interactive run with the priced, identical API when you move from a worksheet demo to an automated pipeline without changing the mathematical result or re-implementing time-and-a-half yourself.
Integration use cases
Deterministic payroll fixtures
Seed CI and payroll calculators with a stable weekly_pay from known rate and hours, and fail closed when any input is not a non-negative number.
Technical questions
How is weekly pay calculated from hourly rate, regular hours, and overtime?
regular_pay is hourly_rate × regular_hours. overtime_pay is hourly_rate × 1.5 × overtime_hours. weekly_pay is the sum of those two lines. The overtime premium is fixed at time-and-a-half.
Does this convert hourly pay into an annual salary?
No. The result is one week's gross. It does not multiply by 52, and it does not infer overtime from hours past 40 — you supply regular_hours and overtime_hours already split.
What does the weekly pay calculator cost?
The browser tool is free. API requests use prepaid KIT balance at $0.002 per successful call; invalid input is not billed.