Georgia overtime calculator
At 18.5 an hour, a 48-hour week in Georgia pays 740 for the first 40 hours plus 222 for 8 overtime hours at 27.75: 962 in total. Check a pay stub or quote a schedule in seconds. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Hourly rate
- 18.5
- Hours worked
- 48
- Weekly threshold
- 40
- Overtime multiplier
- 1.5
- Regular hours
- 40
- Overtime hours
- 8
Georgia does not keep a separate state overtime statute, so non-exempt hourly overtime in Georgia is the federal Fair Labor Standards Act rule: time-and-a-half for hours worked beyond forty in a single workweek, with no daily overtime trigger. This Georgia overtime calculator accepts a non-negative hourly rate and the hours worked in that week, splits the week at the forty-hour FLSA threshold, and returns regular pay plus overtime pay so a payroll clerk, a staffing desk, or a worker can see both pieces of the check. Hours at or below forty stay at the straight-time rate; hours above forty are paid at one and one-half times the hourly rate.
What Georgia overtime means and how the forty-hour week splits
Georgia wage-and-hour practice for overtime follows the federal Fair Labor Standards Act rather than a Georgia-only daily or consecutive-day premium. Non-exempt hourly employees earn one and one-half times their regular hourly rate for hours actually worked over forty in a defined workweek. There is no Georgia daily overtime rule of the kind some other states publish, so a ten-hour Tuesday does not by itself create overtime if the week still ends at or below forty hours.
Zero hours and a zero rate are allowed and produce a zero check, matching unpaid leave or a paused week. The calculator reports gross overtime arithmetic only: it does not classify exempt status, it does not apply the federal minimum wage, it does not withhold tax, and it does not invent shift differentials, on-call retainers, or seventh-day premiums. Those questions belong to a handbook or counsel, not to a weekly split.
What you can do with it
Worker checking a Georgia pay stub
Enter the hourly rate and hours worked to see whether the overtime line matches FLSA time-and-a-half after forty weekly hours.
Staffing desk quoting a Georgia overtime week
Turn a quoted wage and an expected weekly schedule into regular plus overtime pay without mixing Georgia with daily-overtime states.
FAQ
Does Georgia require daily overtime after eight hours?
No. Georgia has no separate state overtime statute and does not add a daily overtime trigger. This calculator applies only the federal FLSA weekly rule: time-and-a-half after forty hours in the workweek.
How is overtime pay calculated in Georgia?
Hours up to 40 in the workweek are paid at your regular rate, and every hour above 40 at one and a half times that rate. With 18.5 an hour and 48 hours, that is 740 regular plus 222 overtime.
Does the calculator tell me whether I am exempt from overtime?
No. It assumes you are a non-exempt hourly worker and only does the weekly arithmetic. Exempt status, the federal minimum wage and tax withholding are questions for your handbook, payroll or a lawyer, and the result is gross pay.
Are shift differentials or seventh-day premiums included?
No. Georgia follows the federal weekly rule only, so the calculator does not add shift differentials, on-call pay or premiums for working a seventh consecutive day. If your employer pays them, they come on top of this result.
What is the most hours I can enter for one week?
Up to 168, the number of hours in seven full days; anything higher cannot be a single week and is refused. Zero hours or a zero rate are fine and simply give a zero check, as for unpaid leave.
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/georgia-overtime \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"hourly_rate":18.5,"hours_worked":48}'const res = await fetch("https://api.kit.forhosting.com/fin/georgia-overtime", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"hourly_rate": 18.5,
"hours_worked": 48
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/fin/georgia-overtime",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"hourly_rate": 18.5,
"hours_worked": 48
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/fin/georgia-overtime", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"hourly_rate":18.5,"hours_worked":48}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"hourly_rate":18.5,"hours_worked":48}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/fin/georgia-overtime", 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": 18.5,
"hours_worked": 48
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "fin.georgia_overtime",
"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_worked | 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
Negative hours worked fail with invalid_input instead of printing a nonsense negative check.
What Georgia overtime means and how the forty-hour week splits
This calculator encodes that weekly identity and nothing else: regular_hours is the lesser of hours_worked and forty, overtime_hours is the excess above forty or zero when the week is shorter, regular_pay is hourly_rate times regular_hours, overtime_pay is hourly_rate times one-point-five times overtime_hours, and total_pay is the sum of those two money amounts rounded to two decimal places. Negative hours_worked cannot describe a schedule, so they are rejected rather than rendered as a refund. Example: an eighteen-dollar-and-fifty-cent rate with forty-eight hours in the week yields forty regular hours and eight overtime hours, so regular_pay is seven hundred forty dollars and overtime_pay is two hundred twenty-two dollars, for a total_pay of nine hundred sixty-two dollars.
Input contract, response shape, and error behaviour
POST a JSON body with two required finite numbers: hourly_rate, the non-negative base wage per hour, with aliases rate, wage, hourly, pay_rate, and hourly_wage; and hours_worked, the hours actually worked in one Georgia workweek, with aliases hours, weekly_hours, hrs, hours_week, and total_hours. hours_worked may be zero through one hundred sixty-eight, the hours in seven twenty-four-hour days; a figure above that ceiling cannot be a single week and is rejected. Each field may arrive as a JSON number or as a numeric string; non-finite values, missing fields, and empty strings fail with invalid_input naming the field. A negative hourly_rate is rejected the same way. On success the body includes the echoed hourly_rate rounded to two decimals; hours_worked as parsed; weekly_threshold always forty; overtime_multiplier always one point five; regular_hours and overtime_hours as the split; ot_hourly_rate as the time-and-a-half wage; regular_pay, overtime_pay, and total_pay as money fields; currency_decimals of two; method georgia_flsa_weekly; and jurisdiction Georgia. Example: hourly_rate of twenty with forty hours yields eight hundred dollars of regular_pay, zero overtime_pay, and a total_pay of eight hundred dollars because the week never crossed the FLSA threshold. Pair the gross figures with your own withholding table if you need net take-home; this endpoint computes regular plus overtime pay only and does not emit a tax line.
Where a Georgia overtime calculator earns its keep
Payroll clerks and bookkeepers in Georgia shops search for a Georgia overtime calculator when they already know the hourly rate and the hours on the timesheet but do not want to split the week by hand or to confuse Georgia with a daily-overtime state. Staffing firms and shift marketplaces live on hourly quotes; applying the forty-hour FLSA split on the Georgia landing gives the same premium a recruiter should expect without forcing them to remember whether Georgia uses eight-hour days. Failed validation does not consume balance. Keep the hourly rate and the hours non-negative, pin the rounded money fields in tests, and you get a reproducible Georgia overtime check for widgets, course modules, and edge workers without standing up a payroll engine of your own. Household budget apps can store the returned total_pay as a weekly inflow when a worker regularly clocks extra hours, then let the user layer rent and savings on a cadence that matches payday. Human-resources microsites and applicant-tracking add-ons can call the same pure module from the browser for a free preview and from the API when they persist a scenario, guaranteeing that the number a visitor saw on a landing page is the number stored after they save. Educators teaching the difference between weekly FLSA overtime and daily overtime can seed classroom examples that fail loudly on negative hours_worked instead of silently printing a minus sign a student might treat as a refund.
Integration use cases
Weekly payroll for Georgia hourly staff
Split a timesheet at forty hours, apply time-and-a-half, and post regular_pay plus overtime_pay on the Georgia workweek before the stub is printed.
Technical questions
How is Georgia overtime calculated from hourly rate and hours worked?
Hours at or below forty are paid at hourly_rate. Hours above forty in the same workweek are paid at hourly_rate times 1.5. The API returns regular_pay, overtime_pay, and total_pay, each rounded to two decimals.
What happens if hours_worked is negative?
The task fails with invalid_input. Negative hours cannot describe a workweek, so the calculator does not print a negative check and the request is not billed.
What overtime multiplier does Georgia use?
Time-and-a-half: overtime_multiplier is 1.5 and weekly_threshold is 40, matching the FLSA rule Georgia follows for non-exempt hourly work. The response also includes ot_hourly_rate as hourly_rate times 1.5.
What does the Georgia overtime calculator cost?
The browser tool is free. API requests use prepaid KIT balance at $0.002 per successful call; invalid input is not billed.