Cronometer MCP server
Read and write your Cronometer food diary from Claude via the mobile API — no Gold subscription needed.
Read the diary: get a day's food log, calories (target/eaten/remaining), per-day nutrient totals, and Cronometer's nutrition scores
Tracked vs untracked nutrients: every nutrient eaten is returned and flagged
tracked, so untracked ones are reported as plain figures rather than omittedSearch the food database: find foods, view full nutrient profiles and serving measures
Log and edit food: add, edit or remove diary entries, copy a day, mark a day complete
Custom foods: create/edit/retire foods with up to all 94 nutrients, merge edits in place, add serving sizes like "1 slice"
Recipes: create/edit recipes from ingredients (with optional cooked weight), choosing a weight- or servings-based type fixed at creation
Audit your library: list all custom foods and recipes, and find every diary entry referencing a food before retiring it
Targets: view and set nutrient minimums/maximums and turn tracking (visibility) on or off
Biometrics: list metrics, read a series over time, add/edit/remove measurements
Fasting: view history and stats, add/edit/delete fasts
Exercise and notes: add/edit/remove exercise entries, write and rewrite daily notes
Run it your way: OAuth 2.1 login for Claude.ai connectors, a fixed token for Claude Code, or a local stdio server with no web layer at all
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@Cronometer MCP server How many calories did I eat yesterday?"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
Cronometer MCP server
Read and write your Cronometer food diary from Claude.ai and Claude Code. It talks to mobile.cronometer.com, the same API the Cronometer Android app uses, and puts an OAuth 2.1 login in front so you can add it to Claude.ai as a custom connector. Claude Code can use a plain token instead. You do not need a Gold subscription, and there is no limit of ten exports a day like there is with CSV export.
Using this server with a paid AI service costs money. Tool definitions and results are billed as input tokens, and an agent can call tools repeatedly on its own. You are responsible for every charge, so set spending limits with your provider. The author accepts no liability for any costs. SeeDISCLAIMER.md.
Why not the other options
Terra API sends your Cronometer data to a webhook, but it can only read, and your food log passes through someone else's servers
gocronometerand similar export tools can only read, and they are rate limitedTools that scrape the Cronometer website can write, but they rely on codes that change every time Cronometer ships an update, and they need Gold
Related MCP server: MacroFactor MCP
Tools
Reading
Tool | What you get |
| Everything in the diary for one day. Each food comes with its name, where it came from, the serving size, how many servings, and what that food added to your nutrients. You also get calories (target, eaten, left) and totals for every nutrient you track |
| Totals for every nutrient eaten that day, each flagged tracked or not |
| Cronometer's nutrition scores |
| Search the food database |
| Full nutrients and serving sizes for one food |
| Your nutrient goals and which nutrients are tracked, named and with units |
| Your protein, carb and fat goals |
| What you can measure, and the units each one accepts |
| One measurement over time |
| Fasts between two dates |
| Fasting totals and averages |
| Every nutrient you can set on a custom food, with units |
| Recently logged foods and how often each was logged |
| Current and record run of fully logged days |
| Account profile: birthdate, gender, timezone, language |
| Your whole custom library, no database results mixed in |
| Your recipes, each with its serving type |
| Every diary entry referencing a food, with dates and amounts |
Writing
Tool | What it does |
| Add a food to a meal, at a given time of day |
| Change how much you ate, or when |
| Delete food entries |
| Create your own food, with up to all 94 nutrients |
| Create or update a recipe from ingredients |
| Edit a custom food in place, keeping its diary entries |
| Edit a recipe in place, keeping its serving type |
| Retire a custom food, or bring one back |
| Write a note on a day |
| Rewrite a note |
| Record a measurement such as weight or body fat |
| Fix a measurement you got wrong |
| Delete a measurement, e.g. a broken scale's reading |
| Add an exercise |
| Delete exercise entries |
| Change how long an exercise lasted, or how much it burned |
| Record a fast, finished or still running |
| Change a fast's times or goal, including ending one that is still running |
| Delete a fast |
| Copy one day's diary onto another day |
| Mark a day done, or not done |
| Set a nutrient's target or limit, or start tracking it |
Custom foods
add_custom_food takes a dict of nutrient name to amount, so you can give it
anything from one nutrient to the whole catalog in a single call:
{
"name": "Vaasan Ruispalat",
"serving_name": "1 slice",
"serving_grams": 33,
"nutrients": {
"energy": 79, "protein": 3.1, "carbs": 12.5, "fiber": 3.4,
"fat": 0.8, "saturated": 0.2, "salt_g": 0.36,
"iron": 0.9, "magnesium": 26, "b1_thiamine": 0.09, "folate": 11
}
}Amounts are for one whole serving, each in that nutrient's own unit. Call
list_nutrients for the accepted names, which come from your account's own
catalog rather than a table baked in here.
A nutrient you leave out stays blank in Cronometer. Passing 0 instead states
that the food contains none of it, and the app treats the two differently, so
only pass what you actually know. An unrecognised name is an error rather than
being quietly dropped, because a food that silently lost a nutrient still looks
complete.
Two conveniences the food label has and the catalog does not: energy_kj is
converted to calories, and salt_g to sodium. Pass one or the other, not both.
update_custom_food takes the same keys, so a food written in label units stays
editable in them.
Recipes
create_recipe takes ingredients rather than nutrient values, and Cronometer
sums the nutrition from them itself:
{
"name": "Overnight oats",
"servings": 2,
"ingredients": [
{"food_id": 450856, "grams": 118},
{"food_id": 465906, "grams": 80}
]
}Find each ingredient's food_id with search_foods first. Portions log in
plain grams with add_food_entry.
Add cooked_grams whenever the dish was baked or simmered. Nutrients are stored
per 100 g, so a dish that lost water is denser than its raw ingredients, and
without it a portion weighed off the plate logs too little.
Cronometer locks a recipe's serving type at creation and it cannot be changed
afterwards, so serving_type matters:
|
| |
Portions | Plain grams everywhere, including the mobile app | Grams through this server; the app offers only a 1 g serving and hides the amount field |
Ingredients | Recorded in the recipe notes | Editable list in Cronometer |
The split exists because Cronometer derives a recipe's weight only from ingredients whose measure is weight-typed, and most database foods use non-weight measures. A real 1802 g recipe came back weighing 446 g, which then skews every per-100 g value. A weight-based recipe therefore has its nutrients summed here and is stored as a plain food, which is exactly why it cannot also carry an editable ingredient list.
Tracked and untracked nutrients
Cronometer's own daily summary covers only nutrients with a target set. Anything else is left out entirely, which for a consumer reading the response is indistinguishable from having eaten none of it. Log a coffee with no caffeine target set, and the day's summary reports no caffeine at all.
get_daily_nutrition and get_food_log therefore return everything eaten, and
mark each nutrient with tracked:
{"id": 262, "name": "Caffeine", "amount": 80.0, "unit": "mg", "tracked": false}tracked: false means no target is set, so the figure stands on its own and
nothing can be said about being over or under. Tracked amounts come from
Cronometer's own totals and match the app; untracked ones are summed from the
day's entries, which reproduces those totals to within rounding.
Pass include_untracked=false for the app's narrower view. Depending on how many
targets you have set, that can easily halve the number of nutrients returned.
Setting targets
set_nutrient_target covers both the goal and whether a nutrient is tracked at
all, which is what makes a micronutrient appear in the diary:
{"nutrient": "protein", "minimum": 145}
{"nutrient": "iodine", "visible": true}
{"nutrient": "sodium", "maximum": 2300}Cronometer's endpoint replaces the whole row rather than patching it, so this reads the nutrient's current settings and merges your change into them. Turning on visibility therefore keeps whatever target was already set, and each call reports the previous values alongside the new ones.
Editing and auditing your library
update_custom_food and update_recipe patch in place: only what you pass
changes, and entries already logged stay attached to the same food while their
nutrition follows the edit. So a typo, a stripped ä, or one wrong nutrient is
fixed without recreating the food and re-logging every entry. Nutrients merge
into the existing profile rather than replacing it.
list_custom_foods returns the whole library with nothing from the database
mixed in, which is what makes an audit possible. Before retiring a food, run
find_entries_by_food to see where it was logged, or its entries are left
pointing at something retired.
Serving type stays fixed: update_recipe will not change it, because
Cronometer locks it at creation.
Neither tool can drop a measure. A measure id is what diary entries point at,
and Cronometer renders an entry whose measure vanished with the amount in the
calorie column and no timestamp, so a write that would lose one is refused
rather than repaired afterwards. Passing measures patches the ids you name
and leaves the rest alone.
How it fits together
Claude.ai / Claude Code
| HTTPS
Cloudflare Tunnel, or any proxy that gives you HTTPS
|
nginx 127.0.0.1:8431
|
auth-server.js :8432 handles the login and the tokens
|
cronometer-mcp :8430 the server itself, local only
|
mobile.cronometer.comThe server itself has no login of its own, and it refuses to listen on anything but the local machine. So anything that reaches it has already got past the login. That login accepts either an OAuth token, which is what Claude.ai sets up for you, or a fixed token, which is quicker for Claude Code.
Install
git clone https://github.com/rollecode/cronometer-mcp.git
cd cronometer-mcp
./install.shThe installer sets up Python and Node, asks for your Cronometer login and a password for the connector's login page, makes a token, and writes the service files and the nginx site with your own hostname and username filled in.
You need Node 18 or newer, Python 3.12 or newer, and uv.
Putting the server online is left to you, because this is where setups differ the most, and a wrong guess here would put your food diary on the public internet. Point a tunnel or a proxy at 127.0.0.1:8431. With Cloudflare Tunnel:
ingress:
- hostname: cronometer-mcp.example.com
service: http://localhost:8431It has to be HTTPS. OAuth will not work over plain HTTP.
Self-hosting it by hand
If you would rather see every step than run the installer, this is all of it. The end state is two services on your own machine, reachable over HTTPS.
1. Get the code and its dependencies
git clone https://github.com/rollecode/cronometer-mcp.git
cd cronometer-mcp
npm install --omit=dev
uv venv && uv pip install -e .2. Store your Cronometer login
./set-credentials.shIt prompts for your email, password and time zone, and writes them to
~/.config/cronometer-mcp/env with mode 0600. The password is never echoed and
never reaches your shell history. Do it by hand if you prefer:
mkdir -p ~/.config/cronometer-mcp && chmod 700 ~/.config/cronometer-mcp
cat > ~/.config/cronometer-mcp/env <<'EOF'
CRONOMETER_USERNAME=you@example.com
CRONOMETER_PASSWORD=your-password
CRONOMETER_ACCOUNT_TZ=Europe/Helsinki
EOF
chmod 600 ~/.config/cronometer-mcp/envCheck it works before going further. This logs in and prints your diary:
set -a && . ~/.config/cronometer-mcp/env && set +a
.venv/bin/python -c "from cronometer_mcp import CronometerClient; c=CronometerClient(); print(c.get_diary()['summary'])"3. Set the connector password and a token
The password is what you type on the sign-in page when adding the connector in Claude.ai. Only its scrypt hash is stored.
CONFIG_DIR=~/.config/cronometer-mcp node set-password.js 'your-password-here'The token is the shortcut for Claude Code, which sends a header and skips the browser entirely.
openssl rand -hex 32 > ~/.config/cronometer-mcp/token
chmod 600 ~/.config/cronometer-mcp/token4. Install the two services
systemd/ holds both unit files. Replace YOUR_USER with your username and
cronometer-mcp.example.com with your hostname, then:
mkdir -p ~/.cache/cronometer-mcp
sudo cp systemd/cronometer-mcp.service systemd/cronometer-mcp-auth.service /etc/systemd/system/
sudo systemctl daemon-reload
sudo systemctl enable --now cronometer-mcp cronometer-mcp-auth
systemctl status cronometer-mcp cronometer-mcp-authcronometer-mcp is the server itself on :8430, reachable only from the machine
it runs on. cronometer-mcp-auth is the login layer on :8432, and it is the
only thing that talks to :8430.
One trap worth naming, because the symptom is confusing: do not add
IPAddressDeny=any to cronometer-mcp.service. It is a sensible hardening line
for a server that only reads local files, but this one has to reach
mobile.cronometer.com, and with it set every tool call hangs until it times
out while systemd still reports the service as active. Nothing is gained by it
either, since the server already refuses to listen beyond the local machine.
5. Put nginx in front
sudo cp nginx/cronometer-mcp.conf /etc/nginx/sites-enabled/cronometer-mcp
sudo nginx -t && sudo systemctl reload nginxIt listens on 127.0.0.1:8431 and passes everything to the login layer. The
long read timeout and proxy_buffering off matter: the MCP holds the connection
open and sends as it goes, and buffering would stall it.
6. Give it an HTTPS address
A Cloudflare Tunnel avoids opening a router port. Any HTTPS reverse proxy works just as well.
ingress:
- hostname: cronometer-mcp.example.com
service: http://localhost:8431cloudflared tunnel route dns YOUR_TUNNEL cronometer-mcp.example.com
sudo systemctl restart cloudflared7. Check it from outside
curl https://cronometer-mcp.example.com/.well-known/oauth-authorization-server
curl -o /dev/null -w '%{http_code}\n' -X POST https://cronometer-mcp.example.com/mcpThe first returns the login details. The second must return 401: anything else
means the login layer is being bypassed and your diary is exposed.
Then connect a client as described under Connecting.
Updating
git pull
uv pip install -e . && npm install --omit=dev
sudo systemctl restart cronometer-mcp cronometer-mcp-authAfter adding or renaming a tool, press Reconnect on the connector in Claude.ai.
That refreshes the tool list inside a conversation you already have open, and
your sign-in survives it, because tokens live in oauth.db on disk rather than
in memory.
When something is wrong
journalctl -u cronometer-mcp -n 50 --no-pager
journalctl -u cronometer-mcp-auth -n 50 --no-pagerWhat you see | What it usually is |
Tool calls hang, service says active |
|
| Token mismatch, compare the header against |
Sign-in page rejects the password | No hash stored yet, run step 3 |
Login fails asking for a 2FA code | |
| The login layer is down, |
Connecting
Claude.ai. Go to Settings, Connectors, Add custom connector, and give it https://your-host/mcp. Leave the client ID and secret empty. Sign in with the password the installer set. Doing this once covers web, desktop and mobile, because connectors belong to your account rather than one device.
Claude Code, through the browser:
claude mcp add --transport http cronometer https://your-host/mcp --scope userThen run /mcp to sign in.
Claude Code, with a token, no browser:
claude mcp add --transport http cronometer https://your-host/mcp \
--header "Authorization: Bearer $(cat ~/.config/cronometer-mcp/token)" \
--scope userUsing it without a server at all
If Claude runs on the same machine, skip the web server and the login entirely and let it start the MCP directly:
claude mcp add cronometer -- /path/to/cronometer-mcp/.venv/bin/cronometer-mcpIt reads your login from ~/.config/cronometer-mcp/env or from a .env file.
Settings
Variable | What it is for |
| Your Cronometer email |
| Your Cronometer password |
| The time zone your diary days are counted in |
| Your two-factor secret, only if you have two-factor on. Needs the |
| The public address of the server |
| Login server port, 8432 by default |
| Where the MCP server is, |
| Where the password, token and database are kept |
| How long a call may go quiet before it is cut off, 120000 by default |
| MCP server port, 8430 by default |
| Public address, used to advertise the icon to clients |
Everything secret lives in ~/.config/cronometer-mcp/, readable only by you: env holds your Cronometer login, password-hash the password for the connector's login page, token the fixed token, and oauth.db the apps and tokens the login server has handed out. Tokens are stored scrambled, so a stolen copy of the database gives nobody a working key.
Your Cronometer session is saved in ~/.cache/cronometer-mcp/session.json, so restarting the server does not log in again and again and hit Cronometer's limit.
If you use two-factor
A server left running on its own cannot type a code, so it needs the secret behind the code instead:
uv pip install -e '.[totp]'Then set CRONOMETER_TOTP_SECRET to the secret from your authenticator app. Without it, an account with two-factor turned on will fail to log in and tell you exactly this.
Working on the code
uv venv && uv pip install -e . && uv pip install pytest ruff
.venv/bin/python -m pytest tests -q
.venv/bin/python -m ruff check src/ tests/Credits
The Cronometer client started as a copy of rwestergren/cronometer-api-mcp. The login layer comes from rollecode/obsidian-remote-mcp.
Available Tools
41 toolsadd_biometricAIdempotent
Record a biometric measurement, such as weight or body fat.
Use list_biometrics to find metric IDs and their valid unit IDs. Correct a wrong value with edit_biometric, or drop the reading entirely with remove_biometric when the measurement never happened.
Args: metric_id: Metric to record, from list_biometrics. unit_id: Unit the amount is in, from that metric's units. amount: The measured value. date: Date as YYYY-MM-DD (defaults to today).
Inputs: amount (required), unit_id (required), metric_id (required), date. Returns: result
add_custom_foodA
Create a custom food with any nutrients you have, from 1 to all 94.
Amounts are for one whole serving of serving_grams, not per 100 g, each in that nutrient's own unit. Call list_nutrients for the accepted names and their units. Only pass the nutrients you actually know: a nutrient you leave out stays blank in Cronometer, while passing 0 states the food contains none of it, and the app treats those differently. An unrecognised name is an error, so nothing is silently dropped from a food that then looks complete.
Two label conveniences: energy_kj is converted to calories, salt_g to sodium. Pass either one or its underlying nutrient, not both.
After creation, use the returned food_id with add_food_entry to log it.
Args: name: Food name. nutrients: Nutrient name to amount per serving, e.g. {"energy": 250, "protein": 12.5, "vitamin_c": 30, "b12_cobalamin": 1.2}. serving_name: Name for the serving size (default "1 serving"). serving_grams: Weight of one serving in grams (default 100). label_type: "AMERICAN_2016" or "EUROPEAN". notes: Free-text note stored on the food.
Inputs: name (required), nutrients (required), notes, label_type, +2 more. Returns: result
add_exerciseAIdempotent
Log an exercise entry.
A wrong entry can be corrected with edit_exercise or deleted outright with remove_exercise.
Args: name: What the exercise was called. minutes: Duration in minutes. calories_burned: Calories burned, as a positive number. date: Date as YYYY-MM-DD (defaults to today).
Inputs: name (required), minutes (required), calories_burned (required), date. Returns: result
add_fastAIdempotent
Record a fast.
Args: start: When the fast started, as YYYY-MM-DD HH:MM. end: When it ended, same format. Omit for an ongoing fast. goal_hours: Target length in hours.
Inputs: start (required), end, goal_hours. Returns: result
add_food_entryA
Add a food entry to the Cronometer diary.
Use search_foods to find food_id and measure_id, then get_food_details to confirm serving sizes and gram weights.
Args: food_id: Numeric food ID from search_foods results. measure_id: Measure/unit ID from get_food_details. grams: Weight of the serving in grams. Real grams for recipes too: the conversion to Cronometer's batch units happens here. date: Date to log as YYYY-MM-DD (defaults to today). translation_id: Translation ID from search results (usually 0). diary_group: Meal slot -- one of "auto", "breakfast", "lunch", "dinner", "snacks" (case-insensitive, default "auto"). time: Time of day as HH:MM or HH:MM:SS. Defaults to now. Pass the real eating time when logging after the fact; an "auto" diary_group then follows that hour instead of the current one.
Inputs: grams (required), food_id (required), measure_id (required), date, +3 more. Returns: result
add_noteAIdempotent
Add a note to a day in the Cronometer diary.
Cronometer cannot delete notes, only rewrite them, so a note added here can be changed but only removed in the Cronometer app.
Args: text: The note text. date: Date as YYYY-MM-DD (defaults to today).
Inputs: text (required), date. Returns: result
copy_dayA
Copy all diary entries from the previous day to the given date.
Additive -- does not remove existing entries on the destination date.
Args: date: Destination date as YYYY-MM-DD (defaults to today).
Inputs: date. Returns: result
create_recipeAIdempotent
Create a recipe from ingredients, or update one by passing recipe_id.
Cronometer sums the nutrients from the ingredients itself, so unlike add_custom_food you give foods and amounts, not nutrient values. Use search_foods to find each ingredient's food_id and measure_id first.
Cronometer locks a recipe's serving type when it is created and it cannot be changed afterwards, so choose deliberately:
"weight" (default) measures the recipe in grams. Portions log as plain grams in every client, including the mobile app's own entry screen. The ingredient list is recorded in the notes rather than as editable ingredients, because Cronometer will not compute a correct weight from ingredients that use non-weight measures.
"servings" keeps an editable ingredient list in Cronometer, but the mobile app then offers only a 1 g serving and hides the amount field. Logging through this server is still correct in grams.
cooked_grams is the weight of the finished dish. Give it whenever the food was baked or simmered: nutrients are stored per 100 g, and a dish that lost water is denser than its raw ingredients, so without it a portion weighed off the plate logs too little.
Updating with recipe_id replaces the whole ingredient list, so pass every ingredient, not only new ones. Recipes are removed with retire_custom_food, the same as custom foods.
Args: name: Recipe name. ingredients: List of {"food_id": int, "grams": float, "measure_id": int (optional)}. servings: How many portions the batch makes. notes: Free-text note stored on the recipe. recipe_id: Existing recipe to update in place. serving_type: "weight" or "servings". Cannot be changed later. cooked_grams: Weight of the finished dish, if it lost water in cooking.
Inputs: name (required), ingredients (required), notes, servings, +3 more. Returns: result
delete_fastADestructiveIdempotent
Remove a recorded fast.
Args: fast_id: The fast ID, from get_fasting_history.
Inputs: fast_id (required). Returns: result
edit_biometricBIdempotent
Change the value of a recorded biometric.
Args: biometric_id: The biometric ID, from get_food_log. amount: The corrected value, in the unit the entry already uses. date: Date the entry is on as YYYY-MM-DD (defaults to today).
Inputs: amount (required), biometric_id (required), date. Returns: result
edit_exerciseAIdempotent
Change the duration or calorie burn of a logged exercise.
Args: exercise_id: The exercise ID, from get_food_log. minutes: New duration in minutes. calories_burned: New burn, as a positive number. date: Date the entry is on as YYYY-MM-DD (defaults to today).
Inputs: exercise_id (required), date, minutes, calories_burned. Returns: result
edit_fastAIdempotent
Change a recorded fast, including ending one that is still open.
Args: fast_id: The fast ID, from get_fasting_history. start: New start as YYYY-MM-DD HH:MM. end: New end as YYYY-MM-DD HH:MM. goal_hours: New target length in hours.
Inputs: fast_id (required), end, start, goal_hours. Returns: result
edit_food_entryAIdempotent
Change the amount or time of an already logged food entry.
Use get_food_log to find entry IDs.
Args: entry_id: The serving ID of the entry to change. grams: New amount in grams. time: New time as HH:MM or HH:MM:SS. date: Date the entry is on as YYYY-MM-DD (defaults to today).
Inputs: entry_id (required), date, time, grams. Returns: result
edit_noteAIdempotent
Replace the text of an existing diary note.
Args: note_id: The note ID, from get_food_log. text: The replacement text. date: Date the note is on as YYYY-MM-DD (defaults to today).
Inputs: text (required), note_id (required), date. Returns: result
find_entries_by_foodARead-onlyIdempotent
Every diary entry that references a food, with dates and amounts.
Use before replacing or retiring a food, so its entries can be moved rather than left pointing at something retired.
Cronometer cannot search entries by food, so this reads the diary one day at a time and the range costs a request per day. It defaults to the last 30 days; widen it deliberately.
Args: food_id: The food to look for. start_date: First day as YYYY-MM-DD (defaults to 30 days back). end_date: Last day as YYYY-MM-DD (defaults to today).
Inputs: food_id (required), end_date, start_date. Returns: result
get_biometricsARead-onlyIdempotent
Get a biometric time series such as weight or body fat from Cronometer.
Returns the recorded values over the date range as a list of {day, value} points.
Use list_biometrics to find metric_id and unit_id (e.g. Weight is metric_id 1, with unit_id 1 for kg or 2 for lbs).
Args: metric_id: Numeric metric ID from list_biometrics. unit_id: Numeric unit ID from the metric's units in list_biometrics. start_date: Start date as YYYY-MM-DD (defaults to 30 days ago). end_date: End date as YYYY-MM-DD (defaults to today).
Inputs: unit_id (required), metric_id (required), end_date, start_date. Returns: result
get_daily_nutritionARead-onlyIdempotent
Get daily nutrition totals for every nutrient eaten that day.
The response has:
summary: flat macro totals (energy, protein, carbs, net_carbs, fat, fiber, alcohol). A value is null if nothing that day contained it.
nutrients: each with id, name, amount, unit, category, confidence and
tracked.tracked_count and untracked_count.
tracked says whether that nutrient has a target set in Cronometer.
Untracked nutrients are still eaten and still counted here; they simply have
nothing to measure against, and Cronometer's own summary leaves them out. So
an absent nutrient means none was eaten, rather than none being tracked.
Report an untracked amount as a plain figure. It has no target, so never describe it as over, under or on track, and offer set_nutrient_target if a target would be useful.
Args: date: Date as YYYY-MM-DD (defaults to today). include_untracked: Leave true for everything eaten. False restricts the response to nutrients with targets, matching the app's own summary.
Inputs: date, include_untracked. Returns: result
get_fasting_historyARead-onlyIdempotent
Get fasting history from Cronometer.
Returns fasts within the date range including status, timestamps, and duration.
Args: start_date: Start date as YYYY-MM-DD (defaults to 30 days ago). end_date: End date as YYYY-MM-DD (defaults to today).
Inputs: end_date, start_date. Returns: result
get_fasting_statsARead-onlyIdempotent
Get aggregate fasting statistics.
Returns total fasting hours, longest fast, average fast duration, and completed fast count.
Inputs: no named parameters. Returns: result
get_food_detailsARead-onlyIdempotent
Get detailed food information including nutrition and serving sizes.
Use this after search_foods to get the full nutrient profile and available measure_ids needed for add_food_entry.
nutrients is for one serving of serving_grams, keyed and scaled exactly
as add_custom_food and update_custom_food take them, so a value read here
can be written straight back unchanged. Cronometer's own stored rows, per
100 g and by numeric id, are alongside as nutrients_per_100g.
Args: food_id: Food ID from search_foods results.
Inputs: food_id (required). Returns: result
get_food_logARead-onlyIdempotent
Get all diary entries for a given date.
Returns every food entry logged for the day. Each "Serving" entry is enriched (best-effort) with the food's name, source, the serving measure (unit name and grams per unit), the number of servings, and that food's own nutrient profile scaled to the amount eaten. Non-food entries (exercise, biometrics) carry their own name.
Note: the per-entry "nutrients" are each food's individual contribution, which is distinct from the day-level nutrition_summary aggregate below.
Also returns a top-level energy_summary field with pre-computed values most relevant to the user:
total_target_kcal: daily calorie target dynamically adjusted for expenditure and weight goal (equivalent to Cronometer's "Total Target" in the Energy Summary screen)
consumed_kcal: total calories consumed
remaining_kcal: calories remaining to stay on target (total_target_kcal - consumed_kcal). Always report this when summarizing the user's day. Prefer this over manually deriving values from the burn breakdown fields.
Also returns a nutrition_summary field with consumed totals for every nutrient eaten that day:
macros: flat macro totals (energy, protein, carbs, net_carbs, fat, fiber, alcohol)
nutrients: every nutrient with amount, unit and
tracked, which says whether it has a target set in Cronometer. Untracked ones were still eaten; they just have nothing to measure against, so report them as plain figures and never as over or under target.
Args: date: Date as YYYY-MM-DD (defaults to today). include_untracked: Leave true for everything eaten. False restricts the summary to nutrients with targets, matching the app's own summary.
Inputs: date, include_untracked. Returns: result
get_macro_targetsARead-onlyIdempotent
Get current macro targets including weekly schedule and templates.
Returns the weekly macro schedule (which template applies to each day) and all saved macro target templates with their values.
Inputs: no named parameters. Returns: result
get_nutrition_scoresARead-onlyIdempotent
Get nutrition scores with per-nutrient consumed amounts and category grades.
Returns category scores (All Targets, Vitamins, Minerals, Electrolytes, Antioxidants, Immune Support, Metabolism, Bone Health) with the actual consumed amount and confidence level for each nutrient.
This is Cronometer's own scoring, so it covers only nutrients with a target; scoring one without a target would have nothing to score against. Use it to see how close each nutrient is to its target, and get_daily_nutrition when you need everything that was actually eaten.
Args: date: Date as YYYY-MM-DD (defaults to today).
Inputs: date. Returns: result
get_profileARead-onlyIdempotent
The account profile: birthdate, gender, timezone and language.
Inputs: no named parameters. Returns: result
get_recent_foodsARead-onlyIdempotent
Recently logged foods with how often each was logged.
The fastest route for "log my usual": find the food here, then add_food_entry. Recipes are flagged so a whole batch is not logged as one portion by mistake.
Inputs: no named parameters. Returns: result
get_result_pageARead-onlyIdempotent
Read more of a result that was too large to return in one piece.
Any tool whose answer is too large returns its first page with a
paging block. Pass that block's result_id here. Nothing is fetched
again: the stored result is paged, filtered and narrowed.
Args:
result_id: From the paging block of the earlier answer.
offset: First item to return, usually the previous next_offset.
limit: At most this many items. Fewer come back if they would not fit.
fields: Only these keys of each item. Dots reach nested keys, such as
"statistics.sizeOnDisk". The paging.fields list shows what exists.
match: Keep only items whose field contains this text, ignoring case,
for example {"title": "alien", "year": "1979"}.
path: Which list to page when the result holds several, as named in
paging.lists. Defaults to the largest.
Inputs: result_id (required), path, limit, match, +2 more. Returns: result
get_streakARead-onlyIdempotent
Diary logging streaks: current run of fully logged days, and the record.
Args: date: Day to count back from as YYYY-MM-DD (defaults to today).
Inputs: date. Returns: result
get_targetsBRead-onlyIdempotent
Nutrient targets for the account, as shown beside the diary totals.
Inputs: no named parameters. Returns: result
list_biometricsARead-onlyIdempotent
List the biometric metrics tracked in Cronometer.
Returns every metric type the account can record (Weight, Body Fat, Heart Rate, Blood Glucose, Waist Size, Sleep, blood panels, body measurements, etc.). Use the metric_id and a unit_id from the results with get_biometrics.
Inputs: no named parameters. Returns: result
list_custom_foodsARead-onlyIdempotent
Every custom food and recipe you own, with no database results mixed in.
Leave query empty for the whole library. This is the way to audit it: to find, say, every food whose name lost its Finnish characters, list them all and read the names, then fix each with update_custom_food.
Retired foods are hidden by Cronometer's own library listing, so include_retired cannot bring them back; it only affects rows already returned.
Args: query: Narrow the list by name. Empty lists everything. include_retired: Keep retired foods in the result when they appear.
Inputs: query, include_retired. Returns: result
list_nutrientsARead-onlyIdempotent
Every nutrient add_custom_food accepts, with its unit and category.
Read from the account's own catalog, so it stays right as Cronometer adds nutrients. Use the returned keys for the add_custom_food nutrients dict.
Inputs: no named parameters. Returns: result
list_recipesARead-onlyIdempotent
Every recipe you own, with its serving type.
serving_type says which kind each one is: "weight" logs in grams everywhere, "servings" keeps an editable ingredient list but shows a 1 g serving in the mobile app. It is fixed at creation and cannot be changed.
Args: include_retired: Keep retired recipes in the result when they appear.
Inputs: include_retired. Returns: result
mark_day_completeAIdempotent
Mark a diary day as complete or incomplete.
Args: date: Date to mark as YYYY-MM-DD. complete: True to mark complete, False for incomplete.
Inputs: date (required), complete. Returns: result
remove_biometricADestructiveIdempotent
Delete recorded biometrics, such as a reading from a misbehaving scale.
Deleting is right when the measurement never happened or is impossible; edit_biometric is for a value that is merely wrong, since editing keeps the day's entry and its history.
Args: biometric_ids: List of biometric IDs to remove, from get_food_log. date: Date the entries belong to as YYYY-MM-DD (defaults to today).
Inputs: biometric_ids (required), date. Returns: result
remove_exerciseADestructiveIdempotent
Delete logged exercise entries.
Use this for an entry that should not be there at all, such as a duplicate from a tracker sync. edit_exercise is for one whose duration or burn is merely wrong.
Args: exercise_ids: List of exercise IDs to remove, from get_food_log. date: Date the entries belong to as YYYY-MM-DD (defaults to today).
Inputs: exercise_ids (required), date. Returns: result
remove_food_entryADestructiveIdempotent
Remove one or more food entries from the Cronometer diary.
Use get_food_log to find entry IDs.
Args: entry_ids: List of serving/entry IDs to remove. date: Date the entries belong to as YYYY-MM-DD (defaults to today).
Inputs: entry_ids (required), date. Returns: result
retire_custom_foodADestructiveIdempotent
Retire a custom food so it stops being offered for new entries.
This is how Cronometer removes a food; there is no delete. Diary entries that already use it keep working. Pass retired=False to bring it back.
Args: food_id: The custom food's ID. retired: True to retire, False to restore.
Inputs: food_id (required), retired. Returns: result
search_foodsARead-onlyIdempotent
Search Cronometer's food database by name.
Returns matching foods with their IDs and source information. Use the food_id and measure_id from results with add_food_entry, or pass food_id to get_food_details for full nutrition info.
Args: query: Food name or keyword (e.g. "eggs", "chicken breast").
Inputs: query (required). Returns: result
set_nutrient_targetAIdempotent
Set a nutrient's daily target, its upper limit, or whether it is tracked.
Giving a minimum or maximum makes it a custom target, replacing the default Cronometer works out from the profile. Setting visible turns tracking of that nutrient on or off, which is how a micronutrient starts showing up in the diary at all.
Only what you pass changes: the rest of the nutrient's settings are read first and kept, so turning on visibility never disturbs an existing target.
Going back to Cronometer's own default is done in the app, under Settings then Targets. Report the current value from get_targets before overwriting one, so it can be put back by hand if wanted.
Args: nutrient: Nutrient name, e.g. "protein", "iodine", "choline", "biotin". Call list_nutrients for the accepted names. minimum: Daily target, in that nutrient's own unit. maximum: Upper limit, in that nutrient's own unit. visible: True to track the nutrient, False to hide it.
Inputs: nutrient (required), maximum, minimum, visible. Returns: result
update_custom_foodAIdempotent
Edit one of your custom foods in place, keeping its diary entries.
Only what you pass changes. Entries already logged stay attached to this same food and their nutrition follows the edit, so a typo or a wrong nutrient can be fixed without re-logging anything.
Nutrients are merged into the existing profile, so correcting one value leaves the rest alone. Call list_nutrients for the accepted names.
Amounts are for one serving, the same basis get_food_details reports and
returns as serving_grams. That is the food's default measure, which is
not always 100 g: a juice measured in millilitres takes per-millilitre
values. Read the food first and the two always agree.
Args: food_id: The custom food to edit. name: New name. notes: New note text. nutrients: Nutrient name to amount per serving, merged in. measures: [{"measure_id": int, "name": str, "grams": float}] to fix a wrongly weighted measure. name and grams are each optional. Leave measure_id out to ADD a serving size instead, giving name and grams: that is how a food gets a per-piece measure such as "1 karkki" or "1 viipale" alongside plain grams, so it can be logged by the count as well as by weight.
Inputs: food_id (required), name, notes, measures, +1 more. Returns: result
update_recipeAIdempotent
Edit one of your recipes in place, keeping its diary entries.
Only what you pass changes, and the serving type never does: Cronometer fixes it at creation. Passing ingredients replaces the whole list, so send every ingredient rather than only the new ones.
Args: food_id: The recipe to edit. name: New name. notes: New note text. ingredients: Full replacement list of {"food_id": int, "grams": float, "measure_id": int (optional)}. cooked_grams: New finished weight. Weight-based recipes only, and it needs the ingredients too, since the nutrition is recomputed.
Inputs: food_id (required), name, notes, ingredients, +1 more. Returns: result
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 41 tools
Tools are largely distinguishable by resource+action, and the descriptions explicitly clarify tricky pairs (get_food_log vs get_daily_nutrition vs get_nutrition_scores, add_custom_food vs create_recipe vs update_recipe). The main overlap is create_recipe doubling as an update path alongside update_recipe, and get_food_log carrying nutrition_summary that duplicates get_daily_nutrition, which could cause occasional misselection.
Almost all tools follow a clean verb_noun snake_case pattern (get_food_log, add_food_entry, list_biometrics, edit_exercise). The only deviation is the remove_*/delete_* split, with delete_fast breaking from the otherwise consistent remove_* convention used for biometrics, exercises, and entries.
41 tools is heavy and exceeds the comfortable range, though the domain (diary, foods, recipes, biometrics, fasting, targets, notes) is genuinely broad and most tools map to distinct operations. The per-entity CRUD clusters inflate the surface, making it borderline over-scoped.
Coverage is thorough: full CRUD on food entries, custom foods, recipes, biometrics, exercises, fasts, notes, and targets, plus day-level operations, paging, and discovery helpers. The only 'gaps' (no hard delete for foods/notes) are documented Cronometer limitations rather than surface omissions.
Maintenance
Related MCP Connectors
Calorie tracker app for ChatGPT and Claude: read meals, macros, weight and log meals from chat.
Log meals and read your nutrition diary from Claude or ChatGPT.
Calorie, workout and body-weight log inside ChatGPT and Claude. Log meals by text, photo or voice.
Track calories and macros right in Claude or ChatGPT and build a personal nutrition diary
Related MCP Servers
- AlicenseAqualityBmaintenanceEnables nutrition tracking with Cronometer, including food logging, food search, diary management, and nutrition data retrieval via natural language.13MIT
- AlicenseNot gradedqualityDmaintenanceEnables Claude.ai to read your MacroFactor nutrition data and log food back into MacroFactor.1MIT
- AlicenseNot gradedqualityCmaintenanceEnables Claude to access your MyFitnessPal diary—foods, portions, meal and daily nutrition totals, water, exercise, steps, and weight—through a custom connector on web, desktop, and mobile.MIT
- AlicenseNot gradedqualityBmaintenanceConnects compatible AI assistants to a Cronometer account to review nutrition and diary data, search foods, log or remove meals, create custom foods and recipes, and retrieve fasting, biometric, and export history.4MIT