Salary to hourly converter
A salary of 52,000 at 40 hours a week for 52 weeks works out to exactly 25 an hour and 1,000 a week. Use it to weigh an offer letter against a contract or part-time rate. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Annual salary
- 52,000
- Weekly hours
- 40
- Weeks per year
- 52
- Annual hours
- 2,080
- Hourly wage
- 25
- Weekly pay
- 1,000
- Monthly pay
- 4,333.33333333
Job offers, freelance quotes, and career pivots almost always mix annual salary language with hourly thinking. Recruiters post yearly figures; contractors price by the hour; and anyone comparing a salaried role to a contract needs a transparent bridge between the two. The standard equivalent is simple and deterministic: divide the annual salary by the product of hours worked each week and the number of weeks counted in a year. Forty hours a week for fifty-two weeks is two thousand eighty annual hours; a fifty-two thousand salary at that schedule is exactly twenty-five per hour. This calculator accepts those three numbers, returns the hourly wage plus weekly and monthly convenience rates, and rejects zero hours or zero weeks with a clear validation error so division by zero never becomes a fake rate.
Where salary-to-hourly converters show up in real work
Career coaches and recruiters constantly translate yearly offer letters into hourly language so candidates can compare a salaried role against a contract rate or a part-time opportunity; a single trusted oracle speeds workshops and self-serve tools without spreadsheet drift. Freelancers pricing retainers need a transparent product of annual target income divided by planned hours so rate cards stay consistent across marketing pages and invoices. Journalism and policy desks that quote living-wage thresholds often start from annual figures and must report the matching hourly number with a stated hours-and-weeks assumption.
If you later need tax-withholding nets, overtime multipliers, multi-currency conversion, or employer total-cost-of-employment models, treat those as separate search intents and landings rather than overloading this salary to hourly converter page.
What you can do with it
Offer letter vs contract rate
Translate a gross annual salary into an equivalent hourly wage so candidates can compare salaried roles against freelancing or contract day rates.
Part-time and reduced-week schedules
Recompute hourly pay when weekly hours drop below full time or when unpaid weeks shrink the paid year below fifty-two.
FAQ
How is the hourly wage calculated?
The product of weekly hours and weeks per year is the annual hour count used as the denominator.
What happens if weekly hours or weeks per year is zero?
Division by zero is rejected rather than returning Infinity or inventing a fake rate.
Does this include taxes or benefits?
No. The converter uses gross annual salary only. Taxes, benefits, overtime, and currency conversion are out of scope and should use separate tools.
What does it cost?
The browser tool is free and runs locally.
How do I account for unpaid weeks off?
Lower the weeks per year, for example to 50 instead of 52 after two weeks of unpaid leave. Fewer paid weeks mean fewer hours in the year, so the same salary gives a higher hourly equivalent.
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/life/salary-to-hourly \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"annual_salary":52000,"weekly_hours":40,"weeks_per_year":52}'const res = await fetch("https://api.kit.forhosting.com/life/salary-to-hourly", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"annual_salary": 52000,
"weekly_hours": 40,
"weeks_per_year": 52
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/life/salary-to-hourly",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"annual_salary": 52000,
"weekly_hours": 40,
"weeks_per_year": 52
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/life/salary-to-hourly", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"annual_salary":52000,"weekly_hours":40,"weeks_per_year":52}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"annual_salary":52000,"weekly_hours":40,"weeks_per_year":52}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/life/salary-to-hourly", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"annual_salary": 52000,
"weekly_hours": 40,
"weeks_per_year": 52
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "life.salary_to_hourly",
"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
How annual salary becomes an hourly wage
Start from a gross annual salary expressed in a single currency unit. Negative schedules are likewise invalid. The capability does not apply income tax, employer payroll taxes, overtime multipliers, shift differentials, or live exchange rates; those are separate product intents with their own landings when coverage grows. That figure is annual_salary: the yearly pay before tax and benefits, kept in one unit for the whole calculation so no silent currency conversion creeps in. Next choose weekly_hours, the average number of hours you work each week, commonly forty for full-time office roles, thirty-seven point five in some public sectors, or a part-time count for reduced schedules. Then choose weeks_per_year: fifty-two when every calendar week is paid, or a smaller count when unpaid leave, furlough, or seasonal downtime removes weeks from the paid year. The product annual_hours equals weekly_hours times weeks_per_year is the denominator of the conversion. The equivalent hourly wage is hourly_wage equals annual_salary divided by annual_hours. The quotient is exact in exact arithmetic and deterministic in floating-point: identical inputs always produce identical JSON with no random seeds, no wall-clock timestamps, no network calls, and no model drift. From the same inputs the calculator also reports weekly_pay as hourly_wage times weekly_hours and monthly_pay as annual_salary divided by twelve, so comparison tables can show weekly and monthly views without a second call. Weekly hours and weeks per year must be finite and strictly greater than zero: a zero schedule would divide by zero and is rejected with invalid_input rather than inventing Infinity or NaN.
What you send and what you get back
Missing fields, non-numeric strings, NaN, Infinity, zero hours, zero weeks, and negative schedule fields fail with invalid_input and are not charged. On success the response echoes cleaned annual_salary, weekly_hours, and weeks_per_year, provides annual_hours as the product of hours and weeks, returns hourly_wage as the primary rate, includes weekly_pay and monthly_pay as convenience figures, sets method to salary_to_hourly, and formula to hourly_wage equals annual_salary divided by weekly_hours times weeks_per_year so offer letters and blog posts can cite the same expression. A short currency_note reminds clients that no FX conversion is performed. Classic checks include fifty-two thousand at forty hours and fifty-two weeks giving twenty-five per hour, one hundred thousand at forty and fifty-two giving about forty-eight point zero eight, and any zero-hour or zero-week request failing with a hard invalid_input. Pricing for successful API calls is the published base of $0.002 per item; validation failures do not consume prepaid balance.
Where salary-to-hourly converters show up in real work
HR and people-ops teams building compensation bands generate answer keys and comparison grids from the identical hourly_wage figure employees see on the landing page. Personal finance educators teaching work-life tradeoffs ask students to recompute hourly rates after unpaid leave or a reduced week, and need deterministic JSON for auto-graders rather than hand-typed totals that drift under rounding. Because this capability is a pure parse engine, API pricing is the published base of $0.002 per successful item and failed validation does not consume balance.
Integration use cases
Compensation survey fixtures
Bulk-produce hourly equivalents for salary bands and reject zero-hour or zero-week schedules with a hard invalid_input.
Technical questions
Which weeks_per_year value should I use?
Use 52 for a full paid calendar year. Use a lower count (for example 50) when unpaid leave or seasonal downtime removes weeks from the paid year.