Rate of pay calculator
Pay of 800 for 40 hours of work is a rate of 20 per hour. Turn what a shift, a week or a gig actually paid into an hourly figure you can compare with the posted wage. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Total pay
- 800
- Hours worked
- 40
- Hourly rate
- 20
Rate of pay is the simple identity people mean when they type rate of pay calculator: how much you earned per hour from the pay you actually received and the hours you actually worked.
How rate of pay is computed from total pay and hours worked
Rate of pay is the hourly figure you get when you divide the money you earned by the hours you spent earning it. Fractional hours are legitimate: thirty-seven and a half hours of a week, or a six-point-five hour shift, both divide cleanly. Zero pay with positive hours is allowed and prints an hourly rate of zero.
Money fields round half-up to two decimal places and hours round half-up to four so goldens compare byte-for-byte across runtimes. Eight hundred of pay over forty hours is twenty per hour. One thousand of pay over thirty-seven and a half hours is twenty-six point six seven after half-up rounding to cents.
The arithmetic is a single finite division; there is no tax engine, no overtime multiplier, no currency conversion, and no annualization.
Where a rate of pay calculator earns its keep
Workers checking a gig, a shift, or a piece of overtime use a rate of pay calculator to turn a lump they already received into an hourly figure they can compare with the posted wage. A weekend that paid four hundred for sixteen hours is twenty-five an hour; the same four hundred for twenty-five hours is sixteen. Payroll operators pin the same two fields next to a timesheet so a one-line model can be checked against the live run without opening a full payroll engine.
Budget coaches drop a month of pay and the hours that produced it into one hourly rate so a household plan is built on the pace of earning rather than on the headline of a salary letter. Failed validation does not consume balance.
What you can do with it
Turn a lump of pay into an hourly figure
Divide the money you earned on a gig, a shift, or a week by the hours you worked to see the rate of pay you actually received.
FAQ
How is the rate of pay calculated?
Money fields round half-up to two decimal places and hours round half-up to four. Example: 800 of pay over 40 hours is 20 per hour.
Is this the same as converting an annual salary to an hourly wage?
No. A salary-to-hourly converter still needs weekly hours and weeks per year. This calculator divides the pay you already earned by the hours you already worked for that same period.
Can I enter partial hours?
Yes. Hours do not have to be whole numbers, so a week that ends with half an hour or a shift of six and a half hours divides cleanly into an hourly rate.
What happens if I enter zero hours?
The calculator rejects it, along with negative hours, because pay divided by zero hours has no meaning. Zero pay with positive hours is accepted and gives an hourly rate of zero.
Does it account for overtime, taxes or expenses?
No. It applies no overtime multiplier, no tax, no commute or expense deduction and no conversion to a yearly salary. It only divides the pay you received by the hours that earned it.
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/rate-of-pay \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"total_pay":800,"hours_worked":40}'const res = await fetch("https://api.kit.forhosting.com/fin/rate-of-pay", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"total_pay": 800,
"hours_worked": 40
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/fin/rate-of-pay",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"total_pay": 800,
"hours_worked": 40
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/fin/rate-of-pay", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"total_pay":800,"hours_worked":40}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"total_pay":800,"hours_worked":40}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/fin/rate-of-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
{
"total_pay": 800,
"hours_worked": 40
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "fin.rate_of_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_total_pay | 1000000000000000 |
max_hours_worked | 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
This calculator divides total_pay by hours_worked and returns the hourly rate in the same currency unit. It does not annualize a salary, does not subtract commute time or expenses, does not layer overtime multipliers, and does not back into a freelance bill rate from overhead and margin. Zero or negative hours make the rate undefined, so those requests fail with invalid_input and are not billed.
How rate of pay is computed from total pay and hours worked
That is the identity people search for when they type rate of pay calculator, and it is the identity this calculator evaluates: hourly_rate equals total_pay divided by hours_worked. total_pay is the amount you were paid for a period — a shift, a week, a gig, a month, or any other window you already rolled into one number — in one currency. It is not an annual salary that still needs a weeks-per-year assumption, not a bill rate lifted by profit margin, and not a true hourly wage after commute and expenses. hours_worked is the hours in that same period that produced the pay. Zero hours and negative hours make the rate undefined, so the calculator rejects them with invalid_input instead of dividing by zero or inventing a sign. You already chose the period and the currency; this endpoint only divides them.
Input contract, response shape, and error behaviour
Example: eight hundred of pay and forty hours yield an hourly rate of twenty. Example: one thousand of pay and thirty-seven and a half hours yield twenty-six point six seven after half-up rounding to cents. POST a JSON body with two required finite numbers that share one period and one currency. total_pay is the period amount earned and must be greater than or equal to zero; aliases pay, earnings, earned, amount, and gross_pay map to the same field so a worksheet can keep its column names. hours_worked is the hours in that same period and must be strictly greater than zero; aliases hours, work_hours, and time are accepted. Each numeric field may arrive as a JSON number or a numeric string. Missing fields, empty strings, and non-finite values — NaN, Infinity, or text that does not parse as a number — fail with invalid_input naming the field. Those failures are not billed. Zero hours_worked and negative hours_worked fail the same way, because a rate of pay is undefined when the denominator is zero or has the wrong sign. Negative total_pay also fails: pay earned is not a negative figure in this contract. Zero total_pay with positive hours is allowed and prints an hourly rate of zero. On success the body echoes total_pay rounded half-up to two decimal places, hours_worked rounded half-up to four decimal places, hourly_rate as their quotient rounded half-up to two decimal places, and a formula string restating the identity hourly_rate equals total_pay divided by hours_worked. Pair the JSON with your own rule for which hours count — clocked time, billed time, or a shift roster — because this endpoint divides the two numbers you send; it does not look up a timesheet. Pricing is a flat $0.002 per successful request.
Where a rate of pay calculator earns its keep
Keep total_pay non-negative, keep hours_worked strictly positive, pin the rounded hourly_rate in tests, and you get a reproducible rate of pay for worksheets, LMS plugins, and edge workers without standing up a payroll engine of your own.
Integration use cases
Check a timesheet against a one-line model
Pin total_pay and hours_worked next to a live run so a simple identity can be compared with payroll without opening a full engine.
Compare two jobs on the same hourly basis
Drop each job's period pay and hours into one hourly_rate so a weekend gig and a weekday shift can be ranked on the same scale.
Technical questions
Why are zero or negative hours rejected?
A rate of pay is undefined when the hours denominator is zero or negative. hours_worked must be a finite number strictly greater than zero. Those requests fail with invalid_input and are not billed.
Can total_pay be zero?
Yes. Zero pay with positive hours prints an hourly rate of zero. Negative total_pay is rejected with invalid_input because pay earned is not a negative figure in this contract.
What does the rate of 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.