Lever calculator
With a 2 m effort arm and a 0.5 m load arm, a push of 25 N balances a 100 N load, a mechanical advantage of 4. Enter both arm lengths and the load to get the balancing effort for any lever layout. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Effort arm
- 2
- Load arm
- 0.5
- Load
- 100
- Effort
- 25
- Mechanical advantage
- 4
- Precision
- 10
This lever calculator finds the effort force you need to hold a load in balance on an ideal lever when you know the effort arm, the load arm, and the load. The definition is static moment balance about the fulcrum: effort times effort arm equals load times load arm, so effort equals load times load arm divided by effort arm. Ideal mechanical advantage is effort arm divided by load arm, which tells you how much the lever multiplies force when friction and beam weight are ignored. Zero arm lengths are rejected because division by a zero effort arm is undefined and a zero load arm has no meaning in this model. The engine is fully deterministic arithmetic: no network calls, no sampling, and no date-dependent shortcuts.
What a balanced lever is and what you get
In introductory statics a lever is a rigid bar that rotates about a fixed fulcrum. When the net moment about that fulcrum is zero, the lever is balanced and does not angularly accelerate. With an ideal massless bar and forces applied perpendicular to the bar, the clockwise moment of the load equals the counterclockwise moment of the effort: load times load arm equals effort times effort arm.
Solving for the unknown effort force yields effort equals load times load arm divided by effort arm. The load arm is the distance from the fulcrum to the load; the effort arm is the distance from the fulcrum to where you push or pull.
When the effort arm is longer than the load arm, the ideal mechanical advantage is greater than one and a smaller effort balances a larger load; when the arms are equal the effort equals the load; when the effort arm is shorter you trade force for range of motion. Zero load is valid and yields zero effort when the arms are finite and non-zero.
Where lever balance fits in study, design, and software
Students meet lever balance when a textbook introduces moments, when a lab uses a meter stick and hanging masses, or when a contest problem gives arm lengths and a load and asks for the effort without calculus. Teachers can pre-generate answer keys for modest arm and load values without trusting opaque calculator apps that silently switch units or confuse mass with force.
Developers call the same contract from scripts to seed deterministic test vectors for simple mechanism demos, to normalize user-entered fulcrum geometry before a free-body diagram, or to satisfy programming-challenge statements that demand the effort force rather than a hand-waved sketch. First-order design checks use effort equals load times load arm over effort arm when only geometry and a design load are known before safety factors, friction, or multi-link linkages are modeled.
What you can do with it
Homework and lab checks
Compute balancing effort from arm lengths and load before grading worksheets or comparing to hanging-mass experiments.
Tutoring and teaching software
Normalize user-entered arms and load into effort force for interactive lessons and step helpers.
FAQ
What does the lever calculator cost?
It is free in your browser on this page.
What happens if an arm length is zero?
A zero effort arm causes division by zero; a zero load arm is undefined in this balance model.
Does this tool model friction or the weight of the bar?
No. It uses the ideal static balance formula only. Real levers with friction or significant beam mass need a fuller free-body analysis.
Which units should I use?
Any consistent pair: arm lengths in the same length unit, load and effort in the same force unit. With metres and newtons, effort is in newtons. The calculator does not convert unit systems.
What if the effort arm is shorter than the load arm?
Then the mechanical advantage is below 1 and you need more force than the load to balance it, in exchange for a longer range of motion. With equal arms, the effort is exactly equal to the load.
Related tools
For developers — API access
Everything on this page is available programmatically. This section is for teams who want to wire it into their own systems; everyone else can just use the tool above.
API endpoint
Prefer to automate it? One authenticated POST creates the task; the result comes back by webhook or a signed link. The same capability also runs here on the web, by email and from Telegram — and soon from our app too.
Call it from your stack
curl -X POST https://api.kit.forhosting.com/mech/lever \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"effort_arm":2,"load_arm":0.5,"load":100}'const res = await fetch("https://api.kit.forhosting.com/mech/lever", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"effort_arm": 2,
"load_arm": 0.5,
"load": 100
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/mech/lever",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"effort_arm": 2,
"load_arm": 0.5,
"load": 100
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/mech/lever", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"effort_arm":2,"load_arm":0.5,"load":100}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"effort_arm":2,"load_arm":0.5,"load":100}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/mech/lever", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"effort_arm": 2,
"load_arm": 0.5,
"load": 100
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "mech.lever",
"status": "queued",
"_links": {
"result": "/tasks/tsk_…/result"
}
}The API is asynchronous: the call returns a task_id immediately and the result arrives by webhook. Polling is capped at 1 req/s per task.
Pricing
Published price — no tokens, no invented credits. A failed task is never charged.
Limits
max_abs_arm | 1000000000000000 |
max_abs_load | 1000000000000000 |
Errors
| HTTP | Code | Meaning |
|---|---|---|
401 | unauthorized | Missing or invalid API key. |
402 | insufficient_balance | Your balance doesn't cover the task price. |
404 | unknown_type | That task type doesn't exist. |
429 | rate_limited | Too many requests. Use the webhook instead of polling. |
Technical notes
What a balanced lever means and what the response contains
This calculator returns the normalized inputs effort_arm, load_arm, and load, the computed effort, the ideal mechanical_advantage, the precision used, a method tag lever_balance, a short formula reminder, and a unit hint that effort uses the same force unit as load. There is no numerical integration of beam deflection and no Monte Carlo sampling of friction: the engine either evaluates the closed form inside the supported numeric range or rejects the input with invalid_input. Rejected cases include a missing arm or load, non-finite values, magnitudes above the documented ceilings, and any arm length that is zero or numerically zero, because the balance equation divides by the effort arm and a zero load arm is undefined here.
How arms and load are read and how effort stays reproducible
Load may be positive or negative if you use a signed axis convention; the product and division preserve the sign. Optional leading plus signs and scientific notation on numeric strings are allowed when they parse as finite decimals; embedded spaces and non-numeric tokens are rejected. The preferred field for the effort arm is effort_arm, but aliases effortArm, ea, d_e, de, and effort_distance are accepted so spreadsheets, query strings, and typed forms can reuse the same contract. The preferred field for the load arm is load_arm, with aliases loadArm, la, d_l, dl, load_distance, and resistance_arm. Both arms must be finite and non-zero: a zero or near-zero value fails with invalid_input and a message that names the field and explains that the lever balance equation is undefined for a zero arm, so a bad cell does not become a silent nonsense result. The preferred field for the load force is load, with aliases L, force_load, resistance, W, and weight. An optional precision field, with aliases decimals and dp, chooses how many decimal places to expose for the numeric outputs, defaulting to ten and capped at fifteen so JSON goldens stay stable. Pair the free browser run on this page with the priced API when you need the identical mathematical result inside an automated pipeline without re-implementing the lever formula yourself.
Where lever balance fits in study, design, and software
Product and education tools use the endpoint when a learner types two arms and a load and the UI must show the balancing effort and the ideal mechanical advantage. On this page the work runs entirely in your browser; through the API each successful lookup costs $0.002, failed validation is not charged, and nothing is stored after the response returns. That split — free interactive exploration and a priced, identical API — matches the rest of the KIT tier-A catalog and lets you move from a classroom demo to an automated pipeline without changing the mathematical result. Pair it with weight-force or friction-force helpers when you need related statics, and with other math endpoints when you are building a small lab of free, deterministic physics calculators.
Integration use cases
Deterministic test fixtures
Generate reproducible effort and mechanical-advantage values for unit tests, mechanism demos, and CI assertions.
Technical questions
What formula is used for a balanced lever?
Moment balance about the fulcrum: effort × effort_arm = load × load_arm, so effort = (load × load_arm) / effort_arm. Ideal mechanical advantage is MA = effort_arm / load_arm.