Wake time after sleep cycles calculator
This wake-time calculator adds a chosen number of complete ninety-minute cycles directly to a bedtime.
Run — free
Enter a strict 24-hour clock time and an integer cycle count, and it returns one precise wake time together with the total planned sleep duration and any day rollover. The calculation runs offline, uses no current date or time zone, and gives the same result for the same input every time. It is a scheduling tool based on a common sleep-cycle estimate, not a measurement of your personal sleep stages or medical advice.
Enter bedtime as a precise clock value
Provide bedtime in the 24-hour HH:MM format, including both digits for the hour and minute. For example, use 22:30 for half past ten at night, 00:05 for five minutes after midnight, or 07:00 for seven in the morning. The strict format removes ambiguity between morning and evening and makes the calculation portable across browsers, API clients, spreadsheets, and automated workflows. Values such as 9:30, 25:00, 12:75, or text with an AM or PM suffix are rejected with a clear invalid-input error. Bedtime is treated as the exact starting point for the cycle arithmetic. The calculator does not automatically add time for getting ready, reading, or falling asleep, so include those considerations when choosing the bedtime you submit. It also does not inspect the system clock, infer your location, or attach a calendar date. That means a bedtime entered today and the same bedtime entered next month produce identical results. This explicit clock-only approach is useful when you want a reproducible answer without hidden time-zone or daylight-saving adjustments.
Choose how many ninety-minute cycles to add
Set cycles to a whole number from one through sixteen. Each cycle always contributes exactly ninety minutes, so the total planned duration is the cycle count multiplied by ninety. Four cycles equal 360 minutes, or six hours; five cycles equal 450 minutes, or seven hours and thirty minutes; and six cycles equal 540 minutes, or nine hours. Fractions, numeric strings, zero, negative counts, and values above the documented limit are rejected rather than rounded or silently changed. Fixing the cycle length is central to this calculator’s purpose: it answers the narrow question of what clock time is reached after a selected number of standard ninety-minute blocks. It does not claim that every person’s sleep follows an exact schedule. Real sleep cycles can vary between people and from one night to another, while awakenings, illness, stress, environment, and other factors can affect sleep. Use the result as a simple planning reference. If you need to account for time spent falling asleep, adjust the submitted bedtime yourself so the starting value represents when you expect sleep to begin.
Interpret the wake time and day rollover
The response gives wake_time as a normalized 24-hour clock value and day_offset as the number of midnight boundaries crossed after the supplied bedtime. A day_offset of zero means the result remains within the same clock day. A value of one means the calculated time is on the following day, which is common when bedtime is in the evening. Longer permitted plans can cross more than one midnight, and the offset keeps that fact visible even though the displayed wake time contains no date. The response also repeats bedtime and cycles, identifies the fixed cycle_minutes value, and reports sleep_minutes, making the arithmetic easy to audit or display in another application. For example, adding six cycles means adding 540 minutes before wrapping the result into a standard clock value. No randomness, network request, current date, local time zone, or daylight-saving rule influences the answer. This makes the function suitable for repeatable tests and offline tools. The result should not be read as a guarantee that waking at that minute will feel easy or restorative. Consider total sleep needs and personal circumstances, and consult a qualified health professional when persistent sleep problems or concerning symptoms require individual guidance.
What you can do with it
Set one cycle-based alarm
Turn a planned bedtime and selected cycle count into one unambiguous alarm time.
Check midnight rollover
See both the normalized wake clock and how many day boundaries the calculation crosses.
Add deterministic sleep arithmetic
Use the offline API result in a planner, wellness tool, or repeatable automated workflow.
FAQ
How much does the calculator cost?
The browser calculator is free to use. API requests start at $0.002.
Does the calculation include time needed to fall asleep?
No. It adds cycles directly from bedtime, so submit the time when you want cycle counting to begin.
Can I change the length of a cycle?
No. This calculator intentionally uses a fixed length of ninety minutes for every cycle.
What happens when the result passes midnight?
wake_time wraps to a valid 24-hour value, while day_offset reports the number of midnight boundaries crossed.
Is the result medical advice?
No. It is deterministic scheduling arithmetic based on a common estimate, not a measurement or diagnosis.
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/health/wake-after-cycles \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"bedtime":"22:30","cycles":6}'const res = await fetch("https://api.kit.forhosting.com/health/wake-after-cycles", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"bedtime": "22:30",
"cycles": 6
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/health/wake-after-cycles",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"bedtime": "22:30",
"cycles": 6
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/health/wake-after-cycles", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"bedtime":"22:30","cycles":6}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"bedtime":"22:30","cycles":6}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/health/wake-after-cycles", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"bedtime": "22:30",
"cycles": 6
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "health.wake_after_cycles",
"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. |