Burger grilling time by thickness and doneness calculator
This burger grilling time calculator gives a repeatable estimate for how long to cook each side of a patty based on its thickness and your selected doneness.
Run — free
Choose one of the supported thicknesses, from one-half inch through one and one-half inches, then select medium rare, medium, medium well, or well done. The result comes from a fixed table and is returned in minutes and seconds per side, making it easy to set a timer or add consistent timing guidance to a recipe workflow.
Measure the patty before choosing a table row
Measure the uncooked patty at its thickest central point, because the center is normally the last part to reach the target doneness. The calculator accepts five exact thicknesses: one-half, three-quarter, one, one and one-quarter, and one and one-half inches. Select the closest supported value only when that approximation is acceptable for your kitchen; the API itself does not round or interpolate an unsupported measurement. That strict rule keeps repeated and automated calls predictable. For more consistent results, shape patties to an even thickness and make a shallow indentation in the center so they are less likely to dome while cooking. Keep the starting conditions reasonably similar between batches, since a refrigerator-cold patty and one that has warmed on the counter will not cook identically. The table assumes direct grilling over a properly preheated cooking surface. It does not measure grill temperature, patty weight, meat composition, starting temperature, wind, lid position, or flare-ups, so treat the returned duration as a planned timer setting rather than a measurement of the food itself.
Match doneness to the fixed per-side estimate
After selecting thickness, choose medium rare, medium, medium well, or well done. Each valid pair maps to one fixed number of minutes per side, with no randomness, hidden adjustment, or dependence on the current time. Start timing when the patty reaches the preheated grill, cook for the returned interval, flip once, and use the same interval for the second side. Opening the lid repeatedly, pressing the patty, moving it between hotter and cooler zones, or allowing flames to contact the meat can change the real cooking rate. The doneness label describes the intended cooking target, but elapsed time alone cannot verify internal temperature or food safety. Ground meat can contain bacteria throughout the patty rather than only on its surface, and official guidance may call for a higher internal temperature than a preference such as medium rare. Check the center with a clean, accurate food thermometer and follow the food-safety guidance that applies to the meat and jurisdiction involved. If the measured temperature has not reached the required target, continue cooking even when the table time has elapsed.
Use the answer as a repeatable starting point
The main value of a fixed table is consistency. Identical supported inputs always return the same minutes and seconds, which makes the capability useful in recipe tools, kitchen displays, production checklists, and testable automation. On the first batch with a particular grill and patty recipe, use the estimate, verify the internal temperature, and note whether the equipment consistently cooks faster or slower. Fat percentage, added ingredients, grate material, fuel type, ambient weather, and hot spots all influence actual heat transfer. A short rest after grilling can also change the center temperature and texture, so keep the resting method consistent when comparing batches. The response states time per side rather than total time to make the flip point unambiguous; for a simple two-sided cook, the planned grill duration is twice the returned interval, before any additional cooking needed for temperature verification. The API price is $0.002 per request, while the browser experience uses the same deterministic lookup. Invalid thicknesses, misspelled doneness values, strings where numbers are required, arrays, and missing fields return an input error instead of a guessed result.
What you can do with it
Set a grill timer
Turn a measured patty thickness and chosen doneness into a clear timer interval for each side.
Standardize recipe instructions
Give readers a consistent table-based starting point instead of one ambiguous cooking time for every burger.
Add timing to a cooking app
Use a bounded deterministic lookup that needs no network, clock, randomness, or external service.
FAQ
Is the returned time for one side or both sides?
It is the time for each side. Cook the first side for the returned interval, flip once, and use the same interval for the second side.
Which patty thicknesses are supported?
The fixed table supports 0.5, 0.75, 1, 1.25, and 1.5 inches. Other values return an invalid-input error rather than being rounded.
Does this guarantee the burger is safe to eat?
No. Time and a doneness label cannot verify food safety. Measure the center with a food thermometer and follow applicable official guidance for the meat.
Does the calculator adjust for grill temperature or weather?
No. It is a fixed reference table and does not adjust for equipment, weather, starting temperature, ingredients, or hot spots.
What does an API request cost?
Each API request costs $0.002. The browser version uses the same deterministic lookup logic.
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/cook/grill-burger-time \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"thickness_in":1,"doneness":"medium"}'const res = await fetch("https://api.kit.forhosting.com/cook/grill-burger-time", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"thickness_in": 1,
"doneness": "medium"
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/cook/grill-burger-time",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"thickness_in": 1,
"doneness": "medium"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/cook/grill-burger-time", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"thickness_in":1,"doneness":"medium"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"thickness_in":1,"doneness":"medium"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/cook/grill-burger-time", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"thickness_in": 1,
"doneness": "medium"
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "cook.grill_burger_time",
"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. |