Calculateur jeûne intermittent
Transforme votre premier repas et un ratio de jeûne en heures précises : en commençant à manger à 12:00 avec un rythme 16:8, votre fenêtre va de 12:00 à 20:00 et le jeûne de 20:00 à 12:00 le lendemain. Gratuit dans votre navigateur.
- Gratuit
- Fonctionne dans votre navigateur
- Sans inscription
- Vos données restent sur votre appareil
Lancer gratuitement
Exemple résolu
- Premier repas
- 12:00
- Ratio de jeûne
- 16:8
- Heures de jeûne
- 16
- Heures de repas
- 8
- Début de la prise alimentaire
- 12:00
- Fin de la prise alimentaire
- 20:00
Les plans de jeûne intermittent se définissent par le nombre d'heures pendant lesquelles vous jeûnez face au nombre d'heures où l'alimentation est autorisée chaque jour. Ce calculateur de fenêtre de jeûne intermittent prend l'heure d'horloge de votre premier repas et un ratio quotidien tel que seize pour huit, dix-huit pour six ou quatorze pour dix, puis renvoie le début et la fin exacts de la fenêtre d'alimentation, la fenêtre de jeûne complémentaire et une courte chaîne de formule que vous pouvez afficher à côté du résultat. L'arithmétique est un calcul modulaire pur des minutes de la journée sur un cycle de vingt-quatre heures : pas d'horloge murale, pas de base de fuseaux horaires et pas de graine aléatoire. Utilisez-le pour des planificateurs personnels d'IF, des démos bien-être, des portails de coaching et une automatisation qui a besoin d'une base transparente de fenêtre de repas sans livrer une bibliothèque nutritionnelle complète.
Ce que le modèle de fenêtre de jeûne intermittent calcule à partir du premier repas et du ratio
Les protocoles quotidiens de jeûne intermittent partagent une journée de vingt-quatre heures en un bloc de jeûne de F heures et un bloc d'alimentation de E heures, écrits sous la forme du ratio F deux-points E. Les exemples classiques incluent seize huit, dix-huit six, vingt quatre, quatorze dix et douze douze. Les deux fenêtres sont renvoyées comme chaînes HH:MM à zéros de tête et comme libellés d'intervalle compacts, afin qu'une interface puisse dessiner la ligne du temps de la journée sans analyse supplémentaire.
C'est une aide à la planification uniquement pour les bornes d'horloge : elle ne compte pas les calories, ne recommande pas si le jeûne convient à une condition médicale et n'ajuste pas les horaires de travail à réveil irrégulier. Les personnes enceintes, mineures, en rétablissement d'un trouble alimentaire ou sous suivi clinique ne doivent pas traiter un calculateur gratuit de fenêtre comme un avis médical.
Traitez la sortie comme le planning arithmétique transparent qu'elle doit être : étant donné un premier repas et un ratio publié, voici quand la fenêtre d'alimentation s'ouvre et se ferme et jusqu'où court le jeûne jusqu'au prochain premier repas.
Qui utilise les horaires de fenêtre alimentaire
Les applications bien-être et les portails de coaching ont souvent besoin d'un premier planning d'alimentation transparent dès que l'utilisateur choisit un protocole et une heure préférée de déjeuner ou de dîner, avant tout journal alimentaire ou donnée de glycémie continue. Intégrer ce calculateur fournit une formule publiée, une partition quotidienne fixe et des sorties HH:MM que les équipes produit et support peuvent citer sans rétro-ingénierie d'une bibliothèque d'horaires boîte noire.
Les suiveurs d'habitudes peuvent recalculer les fenêtres lorsque l'utilisateur avance le premier repas pour la lumière d'été ou le retarde pour des dîners sociaux, toujours avec la même fonction pure. Comme le moteur est un travail analytique parse de niveau A —quelques validations entières et des rolls modulaires de minutes—, la latence reste faible et le modèle de coût, plat. Préférez un avis clinique lorsque des décisions médicales dépendent du jeûne, et traitez cette sortie comme l'estimation conventionnelle de fenêtre d'horloge qu'elle doit être : simple, explicable et déterministe.
Cas d’usage
Planificateurs personnels d'IF et applications d'habitudes
Affichez les bornes d'horloge d'alimentation et de jeûne à partir d'un premier repas et d'un protocole choisis, tels que 16:8 ou 18:6, avec des chaînes HH:MM qu'une interface peut souligner sur la ligne du temps de la journée.
Éducation bien-être et widgets de contenu
Démontrez les ratios courants de jeûne intermittent avec un oracle déterministe qui rejette les heures non positives et les ratios qui ne totalisent pas vingt-quatre.
Coaching et reconstruction par lots des plannings
Recalculez les fenêtres d'alimentation quotidiennes pour les protocoles clients à partir de colonnes stockées de premier repas et de ratio, sans bibliothèques Date sensibles au fuseau horaire.
Questions fréquentes
Pourquoi le jeûne plus l'alimentation doivent-ils totaliser 24 heures ?
Cet outil modélise un seul cycle quotidien de jeûne intermittent. Les protocoles multi-jours sont hors périmètre.
S'agit-il d'un avis médical sur le fait de jeûner ?
Non. Il calcule uniquement des bornes d'horloge pour un ratio choisi. Il n'évalue ni la sécurité, ni les calories, ni l'adéquation clinique. Demandez un avis professionnel lorsque des décisions médicales dépendent du jeûne.
À quelle heure se ferme ma fenêtre si je commence à 12:00 en 16:8 ?
Elle se ferme à 20:00, huit heures après votre premier repas. Le jeûne court ensuite de 20:00 jusqu'à 12:00 le lendemain, quand votre premier repas suivant rouvre la fenêtre.
Que se passe-t-il si ma fenêtre de repas dépasse minuit ?
Les horaires font simplement le tour de la journée de 24 heures. Avec un premier repas à 16:00 en 16:8, la fenêtre se termine à 00:00 et le jeûne dure jusqu'à 16:00 le lendemain.
Quels ratios de jeûne puis-je utiliser ?
N'importe quel partage de la journée en heures entières de jeûne et de repas, à condition que les deux parts soient positives et totalisent 24. Les plus courants sont 16:8, 18:6, 14:10, 12:12 et 20:4.
Outils associés
Pour les développeurs — accès API
Tout sur cette page est disponible par programmation. Cette section s'adresse aux équipes qui veulent l'intégrer à leurs systèmes ; les autres peuvent simplement utiliser l'outil ci-dessus.
Endpoint
Authentification par jeton Bearer : un seul POST met la tâche en file d’attente, et le résultat vous parvient par webhook ou lien signé.
Appeler depuis votre stack
curl -X POST https://api.kit.forhosting.com/health/if-eating-window \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"first_meal":"12:00","fasting_ratio":"16:8"}'const res = await fetch("https://api.kit.forhosting.com/health/if-eating-window", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"first_meal": "12:00",
"fasting_ratio": "16:8"
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/health/if-eating-window",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"first_meal": "12:00",
"fasting_ratio": "16:8"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/health/if-eating-window", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"first_meal":"12:00","fasting_ratio":"16:8"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"first_meal":"12:00","fasting_ratio":"16:8"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/health/if-eating-window", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Exemple de requête
{
"first_meal": "12:00",
"fasting_ratio": "16:8"
}Exemple de réponse
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "health.if_eating_window",
"status": "queued",
"_links": {
"result": "/tasks/tsk_…/result"
}
}L’API est asynchrone : chaque appel renvoie un task_id immédiatement, puis vous interrogez l’état à raison d’une requête par seconde.
Tarifs
Le prix est publié, sans tokens ni crédits. Une tâche qui échoue n’est pas facturée.
Erreurs
| HTTP | Code | Signification |
|---|---|---|
401 | unauthorized | Clé API absente ou invalide : vérifiez l’en-tête Authorization. |
402 | insufficient_balance | Solde insuffisant : rechargez votre compte pour lancer cette tâche. |
404 | unknown_type | Type de tâche inconnu : vérifiez le champ type de votre requête. |
429 | rate_limited | Trop de requêtes : ralentissez la cadence, puis réessayez. |
Notes techniques
Champs manquants, heures mal formées, parties de ratio non positives et ratios qui ne totalisent pas vingt-quatre échouent avec invalid_input au lieu d'inventer un planning.
Ce que le modèle de fenêtre de jeûne intermittent calcule à partir du premier repas et du ratio
Ce calculateur ancre le bloc d'alimentation à l'heure à laquelle vous comptez prendre le premier repas : eating_start égale cette heure de first_meal, eating_end égale first_meal plus E heures entières modulo vingt-quatre heures, fasting_start égale eating_end, et fasting_end égale fasting_start plus F heures entières, ce qui revient à first_meal pour tout ratio quotidien valide. Le ratio est normalisé en entiers sans espaces, de sorte que seize deux-points huit avec ou sans espaces se replient sur le même champ fasting_ratio.
Contrat d'entrée, validation, forme de la réponse et erreurs déterministes
Les espaces autour des deux-points sont tronqués. Envoyez en POST un objet JSON avec deux champs chaîne obligatoires. first_meal est une heure d'horloge sur vingt-quatre heures avec zéro facultatif sur l'heure, deux-points et deux chiffres de minutes de zéro zéro à cinquante-neuf ; des exemples comme douze zéro zéro, huit trente et zéro zéro zéro zéro sont acceptés, tandis que vingt-quatre zéro zéro, douze soixante et un douze nu sont rejetés. Les alias meal_time, eating_start et first_meal_time mappent vers le même chemin d'analyse afin que les formulaires conservent leurs noms préférés. fasting_ratio est la chaîne F deux-points E où F et E sont des entiers positifs d'heures entières qui totalisent exactement vingt-quatre ; les alias ratio, protocol et if_ratio sont acceptés. Parties nulles, négatives, fractionnaires ou non numériques échouent avec invalid_input en nommant le champ et la forme attendue. Des ratios comme seize pour sept qui ne totalisent pas vingt-quatre sont rejetés plutôt qu'étirés en silence, car un cycle quotidien d'IF sans partition complète de la journée laisserait des heures résiduelles ambiguës. first_meal ou fasting_ratio manquants, corps nuls et entrées non objet échouent aussi et ne sont pas facturés. En cas de succès le corps inclut toujours first_meal, fasting_ratio, fasting_hours, eating_hours, eating_start, eating_end, fasting_start, fasting_end, eating_window, fasting_window et une chaîne formula qui reformule les décalages modulaires. Exemple : first_meal douze zéro zéro avec fasting_ratio seize deux-points huit produit une fenêtre d'alimentation de huit heures de douze zéro zéro à vingt zéro zéro et un jeûne de seize heures de vingt zéro zéro de retour à douze zéro zéro.
Où une API de fenêtre de jeûne intermittent apporte de la valeur produit et pédagogique
Des scripts par lots qui recalculent des plannings à partir de colonnes de protocole archivées peuvent appeler le même module sans livrer un SDK nutritionnel complet et sans dépendre d'une implémentation hôte de Date qui bascule près des changements d'heure d'été.
Questions techniques
Comment la fenêtre d'alimentation est-elle calculée ?
eating_start est first_meal. eating_end est first_meal plus les heures d'alimentation du ratio F:E, modulo 24 heures. fasting_start égale eating_end ; fasting_end égale fasting_start plus les heures de jeûne, et revient à first_meal.
Quels champs d'entrée sont obligatoires ?
first_meal (HH:MM, 24 heures) et fasting_ratio (F:E avec des entiers positifs totalisant 24). Les alias meal_time, eating_start, first_meal_time, ratio, protocol et if_ratio sont acceptés. Une entrée invalide renvoie invalid_input et n'est pas facturée.
Combien coûte le calculateur de fenêtre de jeûne intermittent ?
Le widget navigateur est gratuit. Les appels API utilisent le solde prépayé KIT à $0.002 par tâche réussie ; une entrée invalide n'est pas facturée.