# One Rep Max and Strength Standards Calculator (`mangudai/my-actor`) Actor

Estimate your one rep max from any set with seven proven formulas, rank a lift against strength standards by bodyweight, score totals with Wilks, DOTS and IPF GL, load the barbell and plan warmups. Pure offline math, no API key, one row per calculation.

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

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

## One rep max and strength standards calculator

Work out how strong a lift is, from every angle, in one run. Give it a weight and rep count and it estimates your one rep max seven different ways. Give it a bodyweight and a lift and it tells you where you sit on the strength ladder. It also scores powerlifting totals, loads the bar, and writes your warmup.

Everything is pure offline math. No API key, no login, no scraping, nothing that can go stale. The same input always returns the same numbers.

### What it does

Send a list of calculations. Each one is an object with a `type` and its own fields. You can mix types in a single run, and one bad row returns an error instead of stopping the others. Output is one row per calculation, with a `primary` headline and the full numeric detail.

Six calculation types:

- **one-rep-max** estimates your 1RM from a weight lifted for a given number of reps. Returns Epley, Brzycki, Lombardi, O'Conner, Wathan, Lander and Mayhew side by side, their average, and a percentage-of-1RM load table from 1 to 12 reps.
- **rep-max-table** takes a known 1RM and projects the load for 1 to 12 reps, both by the standard training percentages and by the Epley model. Optional `roundTo` snaps to your smallest plate jump.
- **strength-standards** classifies a lift as beginner, novice, intermediate, advanced or elite using bodyweight ratios, and shows the weight needed for each level and the next one to chase. Built-in standards for bench, squat, deadlift and overhead press, or supply your own four ratios.
- **wilks-dots** scores a total (or a single lift) with Wilks, Wilks 2, DOTS and IPF GL points, so you can compare lifters across bodyweights. Works in kg or lb.
- **plate-loading** works out which plates to hang per side to hit a target weight, from the standard plate set or your own. Tells you the exact loaded weight and any leftover.
- **warmup** builds a ramp of warmup sets up to a working weight, with reps per set and optional plate rounding.

### Input

```json
{
  "calculations": [
    { "type": "one-rep-max", "weight": 100, "reps": 5, "unit": "kg" },
    { "type": "strength-standards", "lift": "squat", "sex": "female", "bodyweight": 65, "oneRepMax": 100, "unit": "kg" },
    { "type": "wilks-dots", "sex": "male", "bodyweight": 90, "total": 600, "unit": "kg" },
    { "type": "plate-loading", "targetWeight": 142.5, "unit": "kg" }
  ]
}
```

Fields by type:

- one-rep-max: `weight`, `reps`, `unit`
- rep-max-table: `oneRepMax`, `unit`, optional `roundTo`
- strength-standards: `lift`, `sex`, `bodyweight`, `oneRepMax`, `unit`, optional `ratios` (a list of four bodyweight multiples for novice, intermediate, advanced, elite)
- wilks-dots: `sex`, `bodyweight`, `total`, `unit`
- plate-loading: `targetWeight`, `unit`, optional `barWeight`, optional `availablePlates` (a list of plate sizes)
- warmup: `workingWeight`, `unit`, optional `workingReps`, optional `barWeight`, optional `roundTo`

`unit` is `kg` or `lb`. `sex` is `male` or `female`. Every type accepts an optional `label` that is echoed back on the row.

Leave the input empty and it runs six prefilled examples, one of each type.

### Output

One row per calculation. Common fields are `calculationType`, `label`, `primary`, `input`, `unit`, `ok` and `error`. Type-specific fields fill in the rest, for example `estimated1RM` and the seven formula estimates for one-rep-max, `level` and `ratio` for strength-standards, `wilks`, `dots` and `ipfGL` for wilks-dots, and `platesPerSide` with `achievableWeight` for plate-loading. Nested tables like `percentTable`, `repMaxTable` and `warmupSets` carry the full detail.

The Overview table view shows the headline columns. Switch to the full JSON to see the nested tables.

### Notes on the numbers

The 1RM formulas are estimates and agree best at 10 reps or fewer. Above that the row is flagged with lower accuracy. Strength standards are general bodyweight-ratio guidelines for adult raw lifters, not medical or competition thresholds, so treat them as a rough map rather than a verdict. Wilks and DOTS use the published coefficient sets and IPF GL uses the 2020 classic raw constants.

This is a training tool, not medical advice. Warm up properly and lift within your limits.

# Actor input Schema

## `calculations` (type: `array`):

A list of calculations to run. Each item has a type and its own fields. Types: one-rep-max, rep-max-table, strength-standards, wilks-dots, plate-loading, warmup. See the README for every field.

## Actor input object example

```json
{
  "calculations": [
    {
      "type": "one-rep-max",
      "label": "Bench 100kg x 5",
      "weight": 100,
      "reps": 5,
      "unit": "kg"
    },
    {
      "type": "rep-max-table",
      "label": "Squat 1RM 140kg",
      "oneRepMax": 140,
      "unit": "kg",
      "roundTo": 2.5
    },
    {
      "type": "strength-standards",
      "label": "Male deadlift standards",
      "lift": "deadlift",
      "sex": "male",
      "bodyweight": 80,
      "oneRepMax": 200,
      "unit": "kg"
    },
    {
      "type": "wilks-dots",
      "label": "Male 600kg total",
      "sex": "male",
      "bodyweight": 90,
      "total": 600,
      "unit": "kg"
    },
    {
      "type": "plate-loading",
      "label": "Load 142.5kg",
      "targetWeight": 142.5,
      "unit": "kg"
    },
    {
      "type": "warmup",
      "label": "Warmup to 120kg",
      "workingWeight": 120,
      "workingReps": 5,
      "unit": "kg",
      "roundTo": 2.5
    }
  ]
}
```

# Actor output Schema

## `datasetOverview` (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 = {
    "calculations": [
        {
            "type": "one-rep-max",
            "label": "Bench 100kg x 5",
            "weight": 100,
            "reps": 5,
            "unit": "kg"
        },
        {
            "type": "rep-max-table",
            "label": "Squat 1RM 140kg",
            "oneRepMax": 140,
            "unit": "kg",
            "roundTo": 2.5
        },
        {
            "type": "strength-standards",
            "label": "Male deadlift standards",
            "lift": "deadlift",
            "sex": "male",
            "bodyweight": 80,
            "oneRepMax": 200,
            "unit": "kg"
        },
        {
            "type": "wilks-dots",
            "label": "Male 600kg total",
            "sex": "male",
            "bodyweight": 90,
            "total": 600,
            "unit": "kg"
        },
        {
            "type": "plate-loading",
            "label": "Load 142.5kg",
            "targetWeight": 142.5,
            "unit": "kg"
        },
        {
            "type": "warmup",
            "label": "Warmup to 120kg",
            "workingWeight": 120,
            "workingReps": 5,
            "unit": "kg",
            "roundTo": 2.5
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("mangudai/my-actor").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 = { "calculations": [
        {
            "type": "one-rep-max",
            "label": "Bench 100kg x 5",
            "weight": 100,
            "reps": 5,
            "unit": "kg",
        },
        {
            "type": "rep-max-table",
            "label": "Squat 1RM 140kg",
            "oneRepMax": 140,
            "unit": "kg",
            "roundTo": 2.5,
        },
        {
            "type": "strength-standards",
            "label": "Male deadlift standards",
            "lift": "deadlift",
            "sex": "male",
            "bodyweight": 80,
            "oneRepMax": 200,
            "unit": "kg",
        },
        {
            "type": "wilks-dots",
            "label": "Male 600kg total",
            "sex": "male",
            "bodyweight": 90,
            "total": 600,
            "unit": "kg",
        },
        {
            "type": "plate-loading",
            "label": "Load 142.5kg",
            "targetWeight": 142.5,
            "unit": "kg",
        },
        {
            "type": "warmup",
            "label": "Warmup to 120kg",
            "workingWeight": 120,
            "workingReps": 5,
            "unit": "kg",
            "roundTo": 2.5,
        },
    ] }

# Run the Actor and wait for it to finish
run = client.actor("mangudai/my-actor").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 '{
  "calculations": [
    {
      "type": "one-rep-max",
      "label": "Bench 100kg x 5",
      "weight": 100,
      "reps": 5,
      "unit": "kg"
    },
    {
      "type": "rep-max-table",
      "label": "Squat 1RM 140kg",
      "oneRepMax": 140,
      "unit": "kg",
      "roundTo": 2.5
    },
    {
      "type": "strength-standards",
      "label": "Male deadlift standards",
      "lift": "deadlift",
      "sex": "male",
      "bodyweight": 80,
      "oneRepMax": 200,
      "unit": "kg"
    },
    {
      "type": "wilks-dots",
      "label": "Male 600kg total",
      "sex": "male",
      "bodyweight": 90,
      "total": 600,
      "unit": "kg"
    },
    {
      "type": "plate-loading",
      "label": "Load 142.5kg",
      "targetWeight": 142.5,
      "unit": "kg"
    },
    {
      "type": "warmup",
      "label": "Warmup to 120kg",
      "workingWeight": 120,
      "workingReps": 5,
      "unit": "kg",
      "roundTo": 2.5
    }
  ]
}' |
apify call mangudai/my-actor --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/4OzYUPe5EOzlyRk5A/builds/Z8zvE3xuvc0eAGQ5F/openapi.json