ForHosting KIT · Developer Utilities

Intermittent Fasting Eating Window Calculator

This intermittent fasting eating window calculator turns a daily protocol such as 16:8 into practical clock times.

● BetaFree · in your browser
Use it from WebAPIEmailTelegramApp soon

Enter the time when you plan to start eating, and it returns the end of your eating window and the exact time your next fast begins. The calculation uses a strict 24-hour clock and identifies when an end time falls on the following day. It is useful for planning, reminders, calendar entries, meal preparation, or consistent automation without relying on a current date, time zone, or external service.

Translate a fasting ratio into a usable daily schedule

A protocol such as 16:8 describes duration, not a complete schedule. The first number is the number of fasting hours, while the second is the number of hours available for eating during each 24-hour cycle. To turn that ratio into clock times, the calculator also needs your chosen start-eating time. If you choose 12:30 for a 16:8 protocol, the eight-hour eating period ends at 20:30, and the next fast begins at that same instant. This direct relationship makes the result easy to use in a reminder, calendar, meal plan, or personal tracking system. Enter the protocol with one colon and positive whole-hour values, and enter the start with two-digit hours and minutes on a 24-hour clock. The tool deliberately validates these formats strictly. A clear error is safer than silently interpreting an ambiguous value, especially when a calculation is being reused in an automated workflow. The result repeats the normalized protocol and start time alongside both durations, so downstream code can retain the calculation context rather than storing an unexplained end time alone.

Understand midnight crossings and day offsets

Eating windows do not always end on the same calendar day on which they begin. For example, beginning an eight-hour window at 18:30 produces an end time of 02:30. A clock value alone cannot say whether that means earlier on the same day or early on the next day, so the response includes a day offset. An offset of zero means the end occurs later on the same day as the supplied start. An offset of one means it occurs on the following day. Because supported daily protocols contain positive whole-hour portions totaling 24, the calculation never needs a larger offset. The eating-window end and next-fast start carry matching offsets because they represent the same boundary: eating stops exactly when fasting resumes. This explicit representation is especially helpful when creating calendar events, scheduling notifications, or displaying a result in a user interface. Your application can combine the returned clock time and offset with its own local date and time-zone rules. The calculator itself does not assume a location, daylight-saving rule, or date, which keeps its arithmetic deterministic and prevents an apparently simple daily schedule from changing according to the server environment.

Use the result responsibly and consistently

The calculator answers one narrow scheduling question: given a recognized daily fasting protocol and an eating start time, when does the eating window finish and the next fast begin? It does not recommend a protocol, evaluate nutrition, account for medication, decide whether fasting is appropriate, or measure elapsed time from a live clock. Those choices may depend on health, age, pregnancy, activity, medical conditions, and professional advice. Once you have independently chosen a protocol, however, a deterministic calculation can reduce routine mistakes. Use the same 24-hour start time whenever you want a stable repeating schedule, or recalculate when work, sleep, travel, or training changes your preferred window. API automation costs $0.002 per request, while every response uses the same arithmetic and validation rules. Store both the returned time and its day offset if another system will create dated reminders. Also keep the normalized protocol when auditing a schedule, because an end time without its underlying eating duration can be misleading. If an input fails, correct the protocol or clock format instead of attempting to extract a partial result; invalid formats intentionally produce no schedule.

Plan a repeating daily window

Convert a chosen fasting protocol and regular first-meal time into a clear eating cutoff for a personal schedule.

Create reminder times

Use the returned end time and day offset to create a notification for the moment the next fast begins.

Add fasting math to an app

Generate consistent schedule boundaries without depending on device locale, network calls, current dates, or time-zone parsing.

What does a 16:8 protocol mean?

It means 16 fasting hours followed by an 8-hour eating window within a repeating 24-hour cycle.

When does the next fast start?

The next fast starts at exactly the same boundary at which the calculated eating window ends.

What time format should I enter?

Use a two-digit 24-hour time in HH:MM form, such as 09:00, 12:30, or 18:45.

What happens when the eating window crosses midnight?

The returned clock time wraps after 23:59, and a day offset of 1 identifies that the boundary is on the following day.

Which protocol formats are recognized?

Use two positive whole-hour values separated by a colon, with fasting hours first and eating hours second; the values must total 24.

How much does an API calculation cost?

Each API request costs $0.002.

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.

POSThttps://api.kit.forhosting.com/final3/intermittent-fasting-window-calc

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.

curl -X POST https://api.kit.forhosting.com/final3/intermittent-fasting-window-calc \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d '{"protocol":"16:8","start_eating_time":"12:30"}'
{
  "protocol": "16:8",
  "start_eating_time": "12:30"
}
{
  "task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
  "type": "final3.intermittent_fasting_window_calc",
  "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.

Per request$0.002

Published price — no tokens, no invented credits. A failed task is never charged.

HTTPCodeMeaning
401unauthorizedMissing or invalid API key.
402insufficient_balanceYour balance doesn't cover the task price.
404unknown_typeThat task type doesn't exist.
429rate_limitedToo many requests. Use the webhook instead of polling.

Read the full KIT documentation →