Skip to main content
Glama
Cronometer MCP server

Cronometer MCP server

by rollecode

Cronometer MCP server

Version Python Node OAuth

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.

WARNING

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

  • gocronometer and similar export tools can only read, and they are rate limited

  • Tools 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

get_food_log

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

get_daily_nutrition

Totals for every nutrient eaten that day, each flagged tracked or not

get_nutrition_scores

Cronometer's nutrition scores

search_foods

Search the food database

get_food_details

Full nutrients and serving sizes for one food

get_targets

Your nutrient goals and which nutrients are tracked, named and with units

get_macro_targets

Your protein, carb and fat goals

list_biometrics

What you can measure, and the units each one accepts

get_biometrics

One measurement over time

get_fasting_history

Fasts between two dates

get_fasting_stats

Fasting totals and averages

list_nutrients

Every nutrient you can set on a custom food, with units

get_recent_foods

Recently logged foods and how often each was logged

get_streak

Current and record run of fully logged days

get_profile

Account profile: birthdate, gender, timezone, language

list_custom_foods

Your whole custom library, no database results mixed in

list_recipes

Your recipes, each with its serving type

find_entries_by_food

Every diary entry referencing a food, with dates and amounts

Writing

Tool

What it does

add_food_entry

Add a food to a meal, at a given time of day

edit_food_entry

Change how much you ate, or when

remove_food_entry

Delete food entries

add_custom_food

Create your own food, with up to all 94 nutrients

create_recipe

Create or update a recipe from ingredients

update_custom_food

Edit a custom food in place, keeping its diary entries

update_recipe

Edit a recipe in place, keeping its serving type

retire_custom_food

Retire a custom food, or bring one back

add_note

Write a note on a day

edit_note

Rewrite a note

add_biometric

Record a measurement such as weight or body fat

edit_biometric

Fix a measurement you got wrong

remove_biometric

Delete a measurement, e.g. a broken scale's reading

add_exercise

Add an exercise

remove_exercise

Delete exercise entries

edit_exercise

Change how long an exercise lasted, or how much it burned

add_fast

Record a fast, finished or still running

edit_fast

Change a fast's times or goal, including ending one that is still running

delete_fast

Delete a fast

copy_day

Copy one day's diary onto another day

mark_day_complete

Mark a day done, or not done

set_nutrient_target

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:

"weight" (default)

"servings"

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.com

The 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.sh

The 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:8431

It 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.sh

It 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/env

Check 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/token

4. 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-auth

cronometer-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 nginx

It 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:8431
cloudflared tunnel route dns YOUR_TUNNEL cronometer-mcp.example.com
sudo systemctl restart cloudflared

7. 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/mcp

The 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-auth

After 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-pager

What you see

What it usually is

Tool calls hang, service says active

IPAddressDeny on the MCP unit, see step 4

401 on every call from Claude Code

Token mismatch, compare the header against ~/.config/cronometer-mcp/token

Sign-in page rejects the password

No hash stored yet, run step 3

Login fails asking for a 2FA code

See If you use two-factor

502 from nginx

The login layer is down, systemctl status cronometer-mcp-auth

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 user

Then 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 user

Using 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-mcp

It reads your login from ~/.config/cronometer-mcp/env or from a .env file.

Settings

Variable

What it is for

CRONOMETER_USERNAME

Your Cronometer email

CRONOMETER_PASSWORD

Your Cronometer password

CRONOMETER_ACCOUNT_TZ

The time zone your diary days are counted in

CRONOMETER_TOTP_SECRET

Your two-factor secret, only if you have two-factor on. Needs the totp extra

ISSUER

The public address of the server

PORT

Login server port, 8432 by default

UPSTREAM

Where the MCP server is, http://127.0.0.1:8430 by default

CONFIG_DIR

Where the password, token and database are kept

CALL_TIMEOUT_MS

How long a call may go quiet before it is cut off, 120000 by default

MCP_PORT

MCP server port, 8430 by default

MCP_PUBLIC_URL

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 tools
add_biometricA
Idempotent

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_exerciseA
Idempotent

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_fastA
Idempotent

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_noteA
Idempotent

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_recipeA
Idempotent

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_fastA
DestructiveIdempotent

Remove a recorded fast.

Args: fast_id: The fast ID, from get_fasting_history.

Inputs: fast_id (required). Returns: result

edit_biometricB
Idempotent

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_exerciseA
Idempotent

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_fastA
Idempotent

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_entryA
Idempotent

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_noteA
Idempotent

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_foodA
Read-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_biometricsA
Read-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_nutritionA
Read-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_historyA
Read-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_statsA
Read-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_detailsA
Read-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_logA
Read-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_targetsA
Read-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_scoresA
Read-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_profileA
Read-onlyIdempotent

The account profile: birthdate, gender, timezone and language.

Inputs: no named parameters. Returns: result

get_recent_foodsA
Read-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_pageA
Read-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_streakA
Read-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_targetsB
Read-onlyIdempotent

Nutrient targets for the account, as shown beside the diary totals.

Inputs: no named parameters. Returns: result

list_biometricsA
Read-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_foodsA
Read-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_nutrientsA
Read-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_recipesA
Read-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_completeA
Idempotent

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_biometricA
DestructiveIdempotent

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_exerciseA
DestructiveIdempotent

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_entryA
DestructiveIdempotent

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_foodA
DestructiveIdempotent

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_foodsA
Read-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_targetA
Idempotent

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_foodA
Idempotent

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_recipeA
Idempotent

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

    A4/5.0

    Scored across 41 tools

    Disambiguation4/5

    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.

    Naming Consistency4/5

    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.

    Tool Count3/5

    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.

    Completeness5/5

    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

    ActivitySlowing
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      A
      quality
      B
      maintenance
      Enables nutrition tracking with Cronometer, including food logging, food search, diary management, and nutrition data retrieval via natural language.
      13
      MIT
    • A
      license
      Not graded
      quality
      C
      maintenance
      Enables 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
    • A
      license
      Not graded
      quality
      B
      maintenance
      Connects 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.
      4
      MIT