Beam deflection calculator
A load of 48 at the center of a simply supported span of 2, with a modulus of 200 and a moment of inertia of 4 in consistent units, gives a maximum deflection of 0.01 by PL³/(48EI). Compare it with your deflection limit straight away. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Load
- 48
- Length
- 2
- Elastic modulus
- 200
- Moment of inertia
- 4
- Deflection
- 0.01
- Configuration
- simply_supported_center_point_load
Beam deflection is the vertical displacement of a structural member under load, and for a simply supported span with a concentrated force at midspan the classical Euler–Bernoulli result is a single closed form: maximum deflection equals the load times length cubed over forty-eight times elastic modulus times second moment of area. Students checking homework, civil and mechanical engineers sizing preliminary sections, makers verifying a shelf or bridge model, and automated design pipelines all need that number without opening a finite-element suite every time.
What simply supported midspan deflection means and when the formula applies
A simply supported beam rests on supports that prevent vertical displacement at each end while allowing free rotation, so bending moment is zero at the ends and peaks under a symmetric center load. Under Euler–Bernoulli assumptions—plane sections remain plane, material stays linearly elastic, and deflections remain small relative to span—the peak vertical deflection at midspan for a concentrated force P is PL cubed over forty-eight EI.
Here L is the clear span between supports, E is Young’s modulus of the material, and I is the second moment of area of the cross-section about the bending axis. Search intent clusters around beam deflection calculator, simply supported beam deflection, maximum deflection formula PL3 over 48EI, and midspan point-load beam calculator. People want a numeric δ they can compare to serviceability limits, homework answer keys, or a spreadsheet model—not only a reminder that the formula exists.
Keep units consistent: if P is in newtons, L in metres, E in pascals, and I in metres to the fourth, deflection comes out in metres; any other coherent system works the same way.
What you can do with it
Preliminary structural checks
Engineers and makers estimate maximum deflection for known P, L, E, and I before opening a full FEA model or selecting a catalog section.
FAQ
What formula does this beam deflection calculator use?
For a simply supported beam with a concentrated load P at midspan, maximum deflection is δ = P L³ / (48 E I).
What happens if elastic modulus is zero?
Zero modulus would divide by zero in δ=PL³/(48EI) and is rejected and not charged.
Which load case is supported?
Only a simply supported span with a single point load at midspan. Uniform loads, cantilevers, fixed ends, and off-center loads are out of scope for this capability.
Is the beam deflection calculator free?
The browser tool runs free on your device.
What units should I use for P, L, E, and I?
Any consistent system. For example newtons, metres, pascals, and m⁴ yield deflection in metres. The engine does not convert units for you.
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/sci/beam-deflection \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"load":1000,"length":4,"elastic_modulus":200000000000,"moment_of_inertia":0.0001}'const res = await fetch("https://api.kit.forhosting.com/sci/beam-deflection", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"load": 1000,
"length": 4,
"elastic_modulus": 200000000000,
"moment_of_inertia": 0.0001
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/sci/beam-deflection",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"load": 1000,
"length": 4,
"elastic_modulus": 200000000000,
"moment_of_inertia": 0.0001
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/sci/beam-deflection", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"load":1000,"length":4,"elastic_modulus":200000000000,"moment_of_inertia":0.0001}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"load":1000,"length":4,"elastic_modulus":200000000000,"moment_of_inertia":0.0001}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/sci/beam-deflection", 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": 1000,
"length": 4,
"elastic_modulus": 200000000000,
"moment_of_inertia": 0.0001
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "sci.beam_deflection",
"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
This capability takes load, beam length, elastic modulus, and moment of inertia as finite numbers, rejects zero modulus and other invalid geometry with a clear invalid_input error, and returns the deflection plus echoed inputs and formula labels as structured JSON.
What simply supported midspan deflection means and when the formula applies
Delivering deflection, load, length, elastic_modulus, moment_of_inertia, formula, configuration, and method as JSON makes the result easy to paste into notes, pin in automated tests, or reuse across languages without reimplementing the arithmetic.
How this calculator validates input and applies δ = PL³/(48EI)
Load, length, and moment of inertia must be strictly positive so the geometry and load case stay physically meaningful for this product. There is no distributed-load mode, no cantilever, no off-center load position, and no unit conversion; this is the midspan concentrated-load case only. Send a JSON body with the four required fields load, length, elastic_modulus, and moment_of_inertia. Every field must be a finite number or a numeric string that parses to one; missing fields, empty strings, non-numeric text, NaN, and Infinity all fail immediately with invalid_input before any result is returned, and failed validation is not charged. Elastic modulus must be non-zero: zero modulus is explicitly rejected as invalid_input because it would divide by zero in the classic formula, matching the product contract for this capability. Optional aliases such as P, L, E, I, force, span, youngs_modulus, and inertia are accepted when documented so forms and scripts can use textbook symbols. After validation the engine computes deflection as load times length cubed divided by forty-eight times elastic modulus times moment of inertia, then rounds to a stable precision so the same input always yields the same JSON across JavaScript engines. The same pure function powers the free in-browser tool and the API path, with no network, no random seed, and no wall clock in the computation path.
Practical use, limits, pricing, and delivery channels
Use the browser tool when you want an immediate beam deflection check while grading statics homework, comparing a hand calculation of PL cubed over forty-eight EI, verifying a preliminary section against a deflection limit, or teaching the difference between stiffness from E and stiffness from I. Results are fully deterministic: identical inputs always produce the same deflection and the same formula and configuration labels. There is no language model, no external structural analysis service, and no randomness, so the capacity is safe to pin in continuous-integration checks and reproducible course materials. Each successful request is one billable item at $0.002; failed validation does not consume balance. Choose units consistently and stay within the published magnitude bounds so intermediate products remain finite on a Worker isolate. Wire the endpoint into mechanics drills, contest answer checkers, early-stage design worksheets, or preprocessing steps where you prefer explicit domain errors—such as rejecting zero elastic modulus—over opaque widgets that cannot explain why a bad input was refused.
Integration use cases
Homework and exam verification
Students and graders compute midspan δ for a simply supported beam under a center point load and get a clear invalid_input error when modulus is zero or geometry is non-positive.
Deterministic fixtures for mechanics tests
Pipelines that seed unit tests or interactive beam demos call a pure PL³/(48EI) oracle instead of reimplementing the formula in every language.