# Body Metrics Calculator (`mangudai/body-metrics-calculator`) Actor

Calculate BMI, BMR, TDEE, body fat, ideal weight, healthy weight range and daily calorie and macro targets from height, weight, age, sex and activity. Offline, no API key. Metric or imperial, one or many people, one clean row of results per person.

- **URL**: https://apify.com/mangudai/body-metrics-calculator.md
- **Developed by:** [Mangudäi](https://apify.com/mangudai) (community)
- **Categories:** Developer tools, Automation, Open source
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.01 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Body Metrics Calculator

Calculate BMI, BMR, TDEE, body fat, ideal weight, healthy weight range and daily calorie and macro targets from height, weight, age, sex and activity level. It runs offline with no API key and no scraping, so every run returns the same numbers and nothing breaks when a website changes.

Give it one person or a whole list. You get one clean row per person with every metric filled in.

### What you get for each person

- BMI and the WHO weight category, plus BMI prime and the Ponderal index.
- The healthy weight range for that height, in kilograms.
- BMR from two formulas: Mifflin-St Jeor and the revised Harris-Benedict. Katch-McArdle is added when body measurements are supplied.
- TDEE, your maintenance calories, using the activity level you set.
- Body fat percent. If you give waist and neck (and hip for women), it uses the US Navy method. Otherwise it estimates from BMI with the Deurenberg formula.
- Lean body mass and fat mass in kilograms.
- Ideal weight from four formulas: Devine, Robinson, Miller and Hamwi.
- Daily calorie targets to lose, maintain or gain, at two rates each.
- A starting macro split at maintenance: protein, carbohydrate and fat in grams.

### Input

Pass a `people` array. Each item is one person:

```json
{
  "people": [
    {
      "label": "Alex",
      "units": "metric",
      "sex": "male",
      "age": 30,
      "height": 180,
      "weight": 82,
      "activity": "moderate",
      "waist": 88,
      "neck": 38
    }
  ]
}
````

Fields:

- `label`: any name or id you want on the row. Optional.
- `units`: `metric` or `imperial`. Metric reads height in centimetres and weight in kilograms. Imperial reads height in inches and weight in pounds. Waist, neck and hip follow the same unit.
- `sex`: `male` or `female`. Needed for the BMR, body fat and ideal weight formulas.
- `age`: age in years.
- `height`, `weight`: the two required measurements.
- `activity`: one of `sedentary`, `light`, `moderate`, `active`, `very_active`. Sets the TDEE multiplier from 1.2 to 1.9. Defaults to `moderate`.
- `waist`, `neck`, `hip`: optional. Add them to switch body fat to the US Navy method. Women also need `hip`.

Leave `people` empty and the run uses two example people so you can see the output shape right away.

### Output

One row per person. The table view shows the headline columns (BMI, BMR, TDEE, body fat, ideal weight and the three calorie targets). The full row also carries BMI prime, the Ponderal index, the healthy weight range, both BMR formulas, lean and fat mass, all four ideal weight formulas, both mild and standard calorie targets, and the macro split. A row that fails validation keeps its label and carries an `error` message instead of numbers.

### How the numbers are worked out

- BMI is weight in kilograms divided by height in metres squared. Categories follow the WHO cut points.
- Mifflin-St Jeor is the default BMR and drives TDEE, because it tracks measured resting energy better than Harris-Benedict for most adults.
- The US Navy body fat method uses tape measurements, so it beats a BMI estimate when you supply them.
- Calorie targets sit 250 and 500 kcal below or above maintenance, and never drop below 1200 kcal.

### A note on use

These numbers are estimates for general information, not medical advice. BMI, body fat formulas and calorie targets are population averages and do not account for muscle mass, pregnancy, athletes or clinical conditions. Talk to a doctor or a registered dietitian before making changes to diet or training.

# Actor input Schema

## `people` (type: `array`):

A list of people to calculate. Each item is an object. Fields: label (optional name), units ("metric" or "imperial"), sex ("male" or "female"), age (years), height (cm for metric, inches for imperial), weight (kg for metric, pounds for imperial), activity (sedentary, light, moderate, active, very\_active), and optional waist, neck and hip for the US Navy body fat method (hip is used for women).

## Actor input object example

```json
{
  "people": [
    {
      "label": "Alex",
      "units": "metric",
      "sex": "male",
      "age": 30,
      "height": 180,
      "weight": 82,
      "activity": "moderate",
      "waist": 88,
      "neck": 38
    },
    {
      "label": "Sam",
      "units": "imperial",
      "sex": "female",
      "age": 28,
      "height": 65,
      "weight": 150,
      "activity": "light",
      "waist": 30,
      "neck": 13,
      "hip": 40
    }
  ]
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "people": [
        {
            "label": "Alex",
            "units": "metric",
            "sex": "male",
            "age": 30,
            "height": 180,
            "weight": 82,
            "activity": "moderate",
            "waist": 88,
            "neck": 38
        },
        {
            "label": "Sam",
            "units": "imperial",
            "sex": "female",
            "age": 28,
            "height": 65,
            "weight": 150,
            "activity": "light",
            "waist": 30,
            "neck": 13,
            "hip": 40
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("mangudai/body-metrics-calculator").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "people": [
        {
            "label": "Alex",
            "units": "metric",
            "sex": "male",
            "age": 30,
            "height": 180,
            "weight": 82,
            "activity": "moderate",
            "waist": 88,
            "neck": 38,
        },
        {
            "label": "Sam",
            "units": "imperial",
            "sex": "female",
            "age": 28,
            "height": 65,
            "weight": 150,
            "activity": "light",
            "waist": 30,
            "neck": 13,
            "hip": 40,
        },
    ] }

# Run the Actor and wait for it to finish
run = client.actor("mangudai/body-metrics-calculator").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "people": [
    {
      "label": "Alex",
      "units": "metric",
      "sex": "male",
      "age": 30,
      "height": 180,
      "weight": 82,
      "activity": "moderate",
      "waist": 88,
      "neck": 38
    },
    {
      "label": "Sam",
      "units": "imperial",
      "sex": "female",
      "age": 28,
      "height": 65,
      "weight": 150,
      "activity": "light",
      "waist": 30,
      "neck": 13,
      "hip": 40
    }
  ]
}' |
apify call mangudai/body-metrics-calculator --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=mangudai/body-metrics-calculator",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Body Metrics Calculator",
        "description": "Calculate BMI, BMR, TDEE, body fat, ideal weight, healthy weight range and daily calorie and macro targets from height, weight, age, sex and activity. Offline, no API key. Metric or imperial, one or many people, one clean row of results per person.",
        "version": "0.0",
        "x-build-id": "5CFfegxO7mwnIhFOY"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/mangudai~body-metrics-calculator/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-mangudai-body-metrics-calculator",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/mangudai~body-metrics-calculator/runs": {
            "post": {
                "operationId": "runs-sync-mangudai-body-metrics-calculator",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/mangudai~body-metrics-calculator/run-sync": {
            "post": {
                "operationId": "run-sync-mangudai-body-metrics-calculator",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "people": {
                        "title": "People",
                        "type": "array",
                        "description": "A list of people to calculate. Each item is an object. Fields: label (optional name), units (\"metric\" or \"imperial\"), sex (\"male\" or \"female\"), age (years), height (cm for metric, inches for imperial), weight (kg for metric, pounds for imperial), activity (sedentary, light, moderate, active, very_active), and optional waist, neck and hip for the US Navy body fat method (hip is used for women).",
                        "default": [
                            {
                                "label": "Alex",
                                "units": "metric",
                                "sex": "male",
                                "age": 30,
                                "height": 180,
                                "weight": 82,
                                "activity": "moderate",
                                "waist": 88,
                                "neck": 38
                            },
                            {
                                "label": "Sam",
                                "units": "imperial",
                                "sex": "female",
                                "age": 28,
                                "height": 65,
                                "weight": 150,
                                "activity": "light",
                                "waist": 30,
                                "neck": 13,
                                "hip": 40
                            }
                        ]
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
