Calculateur de macros
Répartissez un objectif calorique quotidien entre protéines, glucides et lipides : 2000 kcal en 30/40/30 donnent 150 g de protéines, 200 g de glucides et 66,7 g de lipides. Choisissez vos propres pourcentages, du moment que leur total fait 100. Gratuit dans votre navigateur.
- Gratuit
- Fonctionne dans votre navigateur
- Sans inscription
- Vos données restent sur votre appareil
Lancer gratuitement
Exemple résolu
- Calories quotidiennes
- 2 000
- Protéines (%)
- 30
- Glucides (%)
- 40
- Lipides (%)
- 30
- Protéines (g)
- 150
Répartit un total calorique journalier entre protéines, glucides et lipides, renvoyant les grammes et les kcal de chacun à partir d'entrées en pourcentage, en utilisant 4 kcal/g pour les protéines et les glucides et 9 kcal/g pour les lipides.
Des calories aux grammes en deux étapes
Un plan de macros part d'un seul nombre, votre objectif calorique quotidien, et de trois parts qui indiquent ce qui vient des protéines, des glucides et des lipides. D'abord, chaque part est appliquée au total : avec 2000 kcal et la répartition par défaut de 30, 40 et 30 %, on obtient 600 kcal de protéines, 800 de glucides et 600 de lipides. Ensuite, l'énergie devient un poids grâce aux facteurs usuels de 4 kcal par gramme pour les protéines et les glucides et de 9 kcal par gramme pour les lipides. Résultat : 150 g de protéines, 200 g de glucides et 66,7 g de lipides.
Les erreurs fréquentes en répartissant ses macros
Diviser toutes les parts par 4 est l'erreur classique : les lipides apportent plus du double d'énergie par gramme, donc les traiter comme des protéines gonfle les grammes. Autre piège, des pourcentages dont le total n'est pas exactement 100 ; ici ils sont refusés au lieu d'être étirés en silence, pour qu'une faute de frappe ne se cache pas dans le plan. Chaque part doit être comprise entre 0 et 100 et l'objectif calorique doit être supérieur à zéro. Les résultats sont arrondis à une décimale par défaut, et vous pouvez en choisir de zéro à deux.
Comment la répartition est calculée
Avec les valeurs par défaut de 30/40/30 sur un objectif de 2000 kcal, cela donne 600, 800 et 600 kcal, qui deviennent 150 g de protéines, 200 g de glucides et 66.7 g de lipides, correspondant exactement à l'exemple livré. La réponse reprend le total calorique et les trois pourcentages, de sorte qu'un appelant peut enregistrer le plan de macros complet à partir d'une seule requête sans rien recalculer côté client.
Cas d’usage
Applications de nutrition et de régime
Transformez l'objectif calorique d'un utilisateur et le ratio de macros choisi en un plan journalier gramme par gramme sans expédier la formule dans le client.
Questions fréquentes
Que se passe-t-il si je n'envoie que les calories ?
Il utilise la répartition par défaut de 30 % de protéines, 40 % de glucides et 30 % de lipides, de sorte qu'une seule valeur calories renvoie une décomposition complète des macros.
Pourquoi les grammes fois quatre ne correspondent-ils pas exactement aux kcal ?
Les grammes et les kcal sont chacun arrondis indépendamment à partir de la valeur énergétique non arrondie, de sorte que leurs formes arrondies peuvent légèrement différer, par conception.
Comment calculer les grammes de protéines à partir des calories ?
Multipliez l'objectif calorique par la part de protéines, puis divisez par 4, l'énergie de chaque gramme. Avec 2000 kcal et 30 % de protéines, cela fait 600 kcal, soit 150 g de protéines par jour.
Pourquoi divise-t-on les lipides par 9 et non par 4 ?
Parce que chaque gramme de lipides apporte 9 kcal, contre 4 pour les protéines et les glucides. C'est pourquoi 600 kcal de lipides ne représentent que 66,7 g, contre 150 g pour la même énergie en protéines.
Que se passe-t-il si mes pourcentages ne font pas 100 ?
La répartition est refusée au lieu d'être réajustée en silence. Une combinaison comme 30, 40 et 29 échoue : corrigez l'une des parts jusqu'à ce que les trois totalisent exactement 100, puis recommencez.
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/dev/macro-calculator \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"calories":2000}'const res = await fetch("https://api.kit.forhosting.com/dev/macro-calculator", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"calories": 2000
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/dev/macro-calculator",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"calories": 2000
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/dev/macro-calculator", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"calories":2000}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"calories":2000}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/dev/macro-calculator", 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
{
"calories": 2000
}Exemple de réponse
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "dev.macro_calculator",
"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
Comment la répartition est calculée
Il multiplie calories par chaque pourcentage sur 100 pour obtenir protein_kcal, carb_kcal et fat_kcal, puis convertit l'énergie en masse à l'aide des facteurs d'Atwater : grammes = kcal / 4 pour les protéines, kcal / 4 pour les glucides et kcal / 9 pour les lipides.
Pourcentages, valeurs par défaut et la règle de la somme à 100
Les trois parts doivent totaliser 100 à une tolérance de 1e-9 près ; sinon l'appel échoue avec le message indiquant que les pourcentages doivent totaliser 100. Cette tolérance est délibérément étroite, de sorte que 30/40/30 passe mais que 30/40/29 est rejeté plutôt que réajusté en silence. calories doit lui-même être un nombre fini strictement supérieur à zéro. protein_percent vaut 30 par défaut, carb_percent 40 et fat_percent 30, de sorte que ne fournir que calories renvoie une répartition équilibrée. Chaque pourcentage doit être un nombre fini compris entre 0 et 100 inclus, vérifié champ par champ, et une valeur hors plage déclenche invalid_input en nommant ce champ.
Arrondi et les six sorties numériques
Le paramètre facultatif decimals vaut 1 par défaut et doit être un entier de 0 à 2 ; toute autre valeur déclenche invalid_input. Parce que les grammes et les kcal sont arrondis séparément, protein_g multiplié par 4 ne redonnera pas toujours le protein_kcal arrondi ; les deux chiffres proviennent de la valeur énergétique non arrondie. Après arrondi, chaque champ numérique est de nouveau vérifié pour sa finitude et un résultat non fini déclenche invalid_input, de sorte que la sortie est toujours un objet JSON propre et entièrement renseigné avec les six nombres de macros présents.
Cas d'intégration
Outils de meal-prep et de coaching
Générez les objectifs de protéines, glucides et lipides pour de nombreux clients à la fois via l'API, chacun avec sa propre répartition en pourcentage.
Contenus et calculateurs de fitness
Intégrez le widget gratuit pour que les visiteurs puissent expérimenter des ratios comme 40/40/20 et voir les grammes se mettre à jour de manière déterministe.
Questions techniques
Quels facteurs de calories par gramme sont utilisés ?
4 kcal par gramme pour les protéines et les glucides et 9 kcal par gramme pour les lipides, la conversion d'Atwater standard appliquée dans lib.js.
Les pourcentages doivent-ils totaliser 100 ?
Oui. protein_percent, carb_percent et fat_percent doivent totaliser 100 à 1e-9 près, sinon l'appel renvoie une erreur invalid_input.
Est-ce gratuit et combien coûte l'API ?
Le widget de navigateur est gratuit (tier A) et exécute le cœur identique ; les appels API sont facturés par requête réussie à partir de $0.002.