The Renpho MCP Server lets you access and analyze body composition data from your Renpho smart scale through MCP-compatible clients like Claude.
Get latest measurement: Fetch your most recent readings — weight, BMI, body fat %, muscle mass, water %, bone mass, visceral fat, metabolic age, BMR, and more
Detailed body composition analysis: Get comprehensive breakdowns with automatic health classifications for BMI, body fat, and visceral fat categories
Track weight trends: Analyze weight changes over customizable periods (1–365 days, default: 30 days)
Browse measurement history: Retrieve historical data filtered by number of days (up to 365) with a configurable result limit (up to 500 records)
View user profile: Access your Renpho account/profile information
Inspect scale users: Discover all linked Renpho scale-user IDs and table mappings for multi-table discovery
Sync diagnostics: Debug hidden or delayed Wi-Fi scale measurements by inspecting linked scale users
Refresh data: Clear caches and force a fresh Renpho API session for the latest data
Health check: Verify server status and API connectivity
Click on "Install 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., "@Renpho MCP Server show my weight trend over the last 30 days"
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.
A Model Context Protocol (MCP) server that provides access to body composition data from Renpho smart scales. Query your weight, body fat, muscle mass, and other health metrics directly from Claude, Cursor, or any MCP-compatible client.
Body Composition Data: Weight, BMI, body fat %, muscle mass, water %, bone mass, visceral fat, metabolic age, BMR, and more
Weight Trends: Track changes over customizable time periods (7-365 days)
Health Classifications: Automatic BMI, body fat, and visceral fat category assessments
Measurement History: Access historical measurements with date filtering
Multi-table discovery: Scans all linked Renpho scale tables instead of assuming the first discovered scale-user ID is always correct
Sync diagnostics: Inspect linked scale-user IDs, hidden measurements, and likely delayed Wi-Fi sync situations
Secure: Credentials stored as environment variables, never logged
Related MCP server: FeelFit MCP Server
Node.js 18+
A Renpho Health account with connected smart scale
Important: This works with the Renpho Health app (blue icon), not the legacy Renpho app
git clone https://github.com/StartupBros/renpho-mcp-server.git
cd renpho-mcp-server
npm install
npm run buildCreate a .env file (or set environment variables):
RENPHO_EMAIL=your-email@example.com
RENPHO_PASSWORD=your-passwordAdd to your MCP settings (~/.claude/settings.json or project .claude/settings.json):
{
"mcpServers": {
"renpho": {
"command": "node",
"args": ["/path/to/renpho-mcp-server/dist/index.js"],
"env": {
"RENPHO_EMAIL": "your-email@example.com",
"RENPHO_PASSWORD": "your-password"
}
}
}
}Add to claude_desktop_config.json:
{
"mcpServers": {
"renpho": {
"command": "node",
"args": ["/path/to/renpho-mcp-server/dist/index.js"],
"env": {
"RENPHO_EMAIL": "your-email@example.com",
"RENPHO_PASSWORD": "your-password"
}
}
}
}Tool | Description |
| Most recent body composition reading selected for the current user |
| Detailed composition with health classifications |
| Weight change analysis over N days |
| Historical measurements with date filtering |
| User profile information |
| Linked scale-user IDs and Renpho table mappings |
| Debug hidden/delayed measurements across linked scale users |
| Clear caches and force a fresh Renpho session |
| Verify API connection status |
Once configured, ask Claude:
"What's my current weight and body composition?"
"Show my weight trend over the last 90 days"
"How has my body fat percentage changed this year?"
"Get my last 10 measurements"
"Show my Renpho scale user IDs"
"Run sync diagnostics for the last 7 days"
"Refresh Renpho data and re-check my latest measurement"
Uses the Renpho Health API (cloud.renpho.com), not the legacy API
Implements AES-128-ECB encryption for API communication
Handles JavaScript BigInt precision for large user IDs
Scans all discovered Renpho scale tables and scale-user IDs before selecting measurements for the current user
Includes a sync diagnostics tool to surface measurements associated with linked scale users but not currently selected for the logged-in user
Caches authentication tokens (50 min) and measurements (5 min) to reduce API calls
Some Wi-Fi scales appear to upload measurements that are not immediately bound to the expected Renpho user until the mobile app performs additional sync logic. This server now helps debug that state with get_scale_users, get_sync_diagnostics, and refresh_data, but the exact server-side binding call used by the app is still being investigated.
Credentials are only used to authenticate with Renpho's API
No data is stored permanently or sent to third parties
All communication uses HTTPS
API reverse engineering based on RenphoGarminSync-CLI by forkerer.
MIT
Get detailed body composition analysis with health classifications
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions 'detailed body composition analysis' and 'health classifications,' which imply a read operation, but fails to specify aspects like data freshness, authentication needs, rate limits, or error conditions. This leaves significant gaps for a tool that likely involves health data.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that front-loads the core purpose ('Get detailed body composition analysis') and adds value with 'health classifications.' There is no wasted verbiage, making it highly concise and well-structured.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity of health data tools and the lack of annotations and output schema, the description is insufficient. It doesn't explain what 'detailed analysis' entails, the format of health classifications, or potential limitations, leaving the agent under-informed for proper tool invocation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 0 parameters with 100% coverage, so no parameter documentation is needed. The description appropriately adds context about what the tool retrieves (body composition analysis with health classifications) without redundant parameter details, aligning with the baseline for zero-parameter tools.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose as 'Get detailed body composition analysis with health classifications,' which specifies the action (get) and resource (body composition analysis). It distinguishes itself from siblings like 'get_weight_trend' by focusing on composition rather than weight trends, though it doesn't explicitly differentiate from 'get_measurements' which might overlap.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives like 'get_measurements' or 'get_latest_measurement.' It lacks explicit instructions on context, prerequisites, or exclusions, leaving the agent to infer usage based on tool names alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get current Renpho user information
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It states the action ('Get') but lacks details on behavioral traits such as authentication requirements, rate limits, error handling, or what specific user information is returned. This leaves significant gaps for an agent to understand the tool's behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that directly states the tool's purpose without any unnecessary words. It's front-loaded and wastes no space, making it highly concise and well-structured.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the lack of annotations and output schema, the description is incomplete. It doesn't explain what user information is returned (e.g., name, email, settings), potential errors, or any context about the Renpho system. For a tool with no structured support, more detail is needed to be fully helpful.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 0 parameters with 100% coverage, so no parameter documentation is needed. The description doesn't add param info, but that's acceptable here as there are no params to explain, meeting the baseline for this scenario.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb ('Get') and resource ('current Renpho user information'), making the purpose understandable. It doesn't distinguish from siblings like 'get_body_composition' or 'get_measurements', but those target different data types, so the distinction is implicit rather than explicit.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No explicit guidance on when to use this tool versus alternatives is provided. The description implies it's for retrieving user info, but it doesn't specify contexts like authentication checks or profile management, nor does it mention any exclusions or prerequisites.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get the most recent body composition measurement from Renpho scale
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It states the tool retrieves data ('Get'), implying a read operation, but doesn't cover aspects like authentication needs, rate limits, error handling, or what happens if no measurements exist. This leaves significant gaps in understanding the tool's behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, clear sentence that directly states the tool's purpose without any fluff or redundancy. It's front-loaded and efficiently communicates the essential information, making it highly concise and well-structured.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity of a data retrieval tool with no annotations and no output schema, the description is incomplete. It doesn't explain what the return value includes (e.g., measurement details, format, or potential errors), which is crucial for an agent to use the tool effectively. More context is needed to compensate for the lack of structured data.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has 0 parameters, and schema description coverage is 100%, so no parameter documentation is needed. The description doesn't add param info, but that's appropriate here. A baseline of 4 is applied as it adequately handles the lack of parameters without introducing confusion.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Get') and resource ('most recent body composition measurement from Renpho scale'), making the purpose unambiguous. However, it doesn't explicitly differentiate from sibling tools like 'get_body_composition' or 'get_measurements', which likely retrieve similar data, so it doesn't reach the highest score.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives. The description doesn't mention any context, prerequisites, or exclusions, leaving the agent to infer usage based on tool names alone, which is insufficient for optimal selection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
| Name | Required | Description | Default |
|---|---|---|---|
| days | No | Number of days to retrieve (default: 30) | |
| limit | No | Maximum number of measurements (default: 100) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Tool has no description.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Tool has no description.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Tool has no description.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Tool has no description.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Tool has no description.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Tool has no description.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
| Name | Required | Description | Default |
|---|---|---|---|
| days | No | Number of days to analyze (default: 30) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Tool has no description.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Tool has no description.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Tool has no description.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Tool has no description.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Tool has no description.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Tool has no description.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Check the health status of the Renpho MCP server and API connection
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden for behavioral disclosure. It states what the tool does but lacks details on behavioral traits: it doesn't specify what 'health status' includes (e.g., server uptime, API latency, authentication status), whether it performs active tests or returns cached data, error handling, or typical response format. This leaves significant gaps for a tool that might be critical for system diagnostics.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, clear sentence that directly states the tool's purpose without any fluff or redundant information. It's appropriately sized for a simple tool and front-loads the essential information efficiently.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's potential complexity in diagnosing server/API issues, the description is incomplete. With no annotations and no output schema, it fails to explain what the health check returns (e.g., status indicators, metrics, error details) or how to interpret results. For a diagnostic tool, this omission could hinder effective use by an AI agent.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has 0 parameters with 100% schema description coverage, so the schema fully documents the absence of inputs. The description appropriately doesn't add parameter details beyond this, as none are needed. A baseline of 4 is justified since no parameters exist to explain, and the description doesn't introduce unnecessary complexity.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Check') and target ('health status of the Renpho MCP server and API connection'), providing a specific verb+resource combination. However, it doesn't explicitly differentiate from sibling tools like 'get_current_user' or 'get_measurements', which serve different purposes rather than being direct alternatives for health checking.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage when health status needs verification, but provides no explicit guidance on when to use this tool versus alternatives (e.g., for troubleshooting connectivity issues before calling other tools). There's no mention of prerequisites, frequency recommendations, or error scenarios that would trigger its use.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.
v1.0.0get_body_compositionget_current_userget_latest_measurementget_measurementsget_weight_trendhealth_checkMost tools have distinct purposes: get_body_composition, get_current_user, get_latest_measurement, and health_check are clearly different. However, get_latest_measurement and get_measurements could be ambiguous without descriptions, as they both relate to measurements but differ in scope (latest vs. all).
All tool names follow a consistent verb_noun pattern using snake_case (e.g., get_body_composition, get_current_user). The naming is predictable and readable throughout the set, with no deviations in style or convention.
With 6 tools, the count is well-scoped for a Renpho health and body composition server. Each tool appears to earn its place by covering user info, measurements, trends, and server health, without being overly sparse or bloated.
The tool set covers core read operations for body composition, measurements, and user info, but lacks obvious write or update capabilities (e.g., no tools for setting user data or logging new measurements). Additionally, get_measurements and get_weight_trend have no descriptions, creating gaps in understanding their full scope and usage.
Unclaimed servers have limited discoverability.
If you are the server author, to access and configure the admin panel.
Body composition for AI: BMI, body fat, FFMI, waist-to-height, plus saved measurement trends.
Read wearables and lab health data — sleep, activity, workouts, timeseries, lab tests and orders.
Your WHOOP data in the assistant, read-only: recovery, sleep, strain, workouts, cycles and body meas
Read-only access to your PumpX workout log: sessions, lift history, PRs, routines, measurements.
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/StartupBros-com/renpho-mcp-server'
If you have feedback or need assistance with the MCP directory API, please join our Discord server