Second-class lever calculator
A wheelbarrow carrying 200 N at 0.4 m from the wheel, lifted at handles 1.2 m from it, needs 66.6666666667 N of effort, a mechanical advantage of 3. Enter the load and both arms to get the balancing effort. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Load
- 200
- Effort arm
- 1.2
- Load arm
- 0.4
- Effort
- 66.6666666667
- Mechanical advantage
- 3
- Lever class
- second
- Precision
- 10
This second-class lever calculator finds the effort force you need to hold a load in balance when the load sits between the fulcrum and the effort—the classic wheelbarrow, bottle-opener, and many door-closer geometries. You enter the load force, the effort arm (distance from fulcrum to where you push or pull), and the load arm (distance from fulcrum to the load). Ideal moment balance about the fulcrum gives effort equals load times load arm divided by effort arm, and the ideal mechanical advantage is the ratio of those arms. A zero effort arm is rejected because the balance equation would divide by zero. The engine is fully deterministic arithmetic: no network calls, no sampling, and no date-dependent shortcuts.
How a second-class lever works and what you see
In introductory statics a lever is a rigid bar that rotates about a fixed fulcrum. Levers are classed by the order of fulcrum, load, and effort along the bar. A second-class lever places the load between the fulcrum and the effort: the fulcrum is at one end, the load rests somewhere along the span, and you apply effort at the free end.
Everyday examples include a wheelbarrow (wheel as fulcrum, cargo as load, handles as effort), a bottle opener that pries under a cap, and a nutcracker where the nut is the load between the hinge and your grip. When the net moment about the fulcrum is zero, the lever is balanced: load times load arm equals effort times effort arm. Solving for effort yields effort equals load times load arm divided by effort arm.
Zero load is valid and yields zero effort when the arms are finite and non-zero.
Where second-class lever balance fits in study, design, and software
Students meet second-class levers when a textbook contrasts first-, second-, and third-class machines, when a lab asks for the handle force on a loaded wheelbarrow, 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 for a wheelbarrow 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
Wheelbarrow and homework checks
Compute balancing handle effort from arm lengths and cargo load before grading worksheets or comparing to lab measurements.
Tutoring and teaching software
Normalize user-entered arms and load into effort force for interactive lessons on class-two machines.
FAQ
What does the second-class lever calculator cost?
It is free in your browser on this page.
What happens if the effort arm is zero?
A zero effort arm causes division by zero in the balance equation, so the task fails instead of returning a nonsense result.
How is a second-class lever different from a first-class lever?
On a second-class lever the load sits between the fulcrum and the effort (wheelbarrow). On a first-class lever the fulcrum is between load and effort (seesaw). The moment-balance formula has the same form, but the geometry and typical MA differ.
Does this tool model friction or the weight of the bar?
No. It models an ideal rigid second-class lever with forces perpendicular to the bar. Friction, beam weight, and deflection are outside scope; use dedicated tools or a full statics model when those matter.
Why is the mechanical advantage of a second-class lever usually above 1?
Because the effort acts at the far end, so the effort arm spans the whole bar while the load sits closer to the fulcrum. That is why a smaller effort can balance a larger 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-second-class \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"load":200,"effort_arm":1.2,"load_arm":0.4}'const res = await fetch("https://api.kit.forhosting.com/mech/lever-second-class", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"load": 200,
"effort_arm": 1.2,
"load_arm": 0.4
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/mech/lever-second-class",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"load": 200,
"effort_arm": 1.2,
"load_arm": 0.4
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/mech/lever-second-class", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"load":200,"effort_arm":1.2,"load_arm":0.4}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"load":200,"effort_arm":1.2,"load_arm":0.4}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/mech/lever-second-class", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"load": 200,
"effort_arm": 1.2,
"load_arm": 0.4
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "mech.lever_second_class",
"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.
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 second-class lever is and what the response contains
Because the effort arm is the full span from fulcrum to your hand and the load arm is shorter when the load sits between them, the ideal mechanical advantage MA equals effort_arm over load_arm is typically greater than one, so a smaller effort balances a larger load. This calculator returns the normalized inputs load, effort_arm, and load_arm, the computed effort, the ideal mechanical_advantage, lever_class set to second, the precision used, a method tag second_class_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 effort arm that is zero or numerically zero, because the balance equation divides by the effort arm.
How arms and load are read and how effort stays reproducible
The load arm must likewise be finite and non-zero. 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 load force is load, with aliases L, force_load, resistance, W, and weight. 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. The effort arm 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 second-class lever balance equation is undefined for a zero effort arm, so a bad cell does not become a silent nonsense result. 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 second-class lever formula yourself.
Where second-class 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 for class-two geometry. 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 on second-class levers.
Technical questions
What formula is used for a second-class 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. The load lies between fulcrum and effort.