Simply supported center-load deflection calculator
A center load of 48 on a span of 2, with a modulus of 200 and a second moment of area of 4, gives a midspan deflection of 0.01 in coherent units. Compare it with a limit such as span over 360. 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
When a simply supported beam carries a single concentrated force at midspan, designers and students need the peak vertical deflection without standing up a full finite-element model. The classical Euler–Bernoulli closed form states that maximum deflection equals the product of load and span cubed divided by forty-eight times the product of elastic modulus and second moment of area.
What simply supported center-load deflection means and when δ = PL³/(48EI) applies
A simply supported beam rests on two end supports that prevent vertical translation while allowing free rotation, so bending moment vanishes at each support and reaches its peak under a symmetric center point load. Under Euler–Bernoulli assumptions—plane sections remain plane after bending, the material responds linearly elastically, shear deformation is neglected relative to flexure, and deflections stay small compared with the span—the peak vertical displacement occurs at midspan and equals P times L cubed over forty-eight E I.
Here P is the concentrated force, L is the clear span between supports, E is Young’s modulus of the beam material, and I is the second moment of area of the cross-section about the axis of bending. Search intent for this landing clusters around simply supported center load deflection calculator, midspan point-load beam deflection, maximum deflection formula PL3 over 48EI, and center-loaded simply supported beam δ.
People want a numeric peak deflection they can compare to serviceability limits such as span over three hundred sixty, to homework answer keys, or to a spreadsheet model—not only a reminder that a textbook formula exists. Keep units consistent throughout: if P is in newtons, L in metres, E in pascals, and I in metres to the fourth, deflection is reported in metres; any other coherent unit system works the same way because the engine does not convert units for you.
Practical use, limits, pricing, and delivery channels for center-load beam checks
Use the browser tool when you want an immediate midspan deflection check while grading statics homework, comparing a hand calculation of P L cubed over forty-eight E I, verifying a preliminary rectangular or I-section against a serviceability deflection limit, or teaching how stiffness from elastic modulus differs from stiffness from second moment of area. Results are fully deterministic: identical inputs always produce the same deflection value 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. When your problem moves to distributed loads, cantilevers, or multi-span frames, switch to a more general analysis tool; this calculator stays focused on the single center point load on a simply supported span so the answer stays transparent and fast.
What you can do with it
Preliminary structural serviceability checks
Engineers and makers estimate maximum center-load deflection for known P, L, E, and I before opening a full FEA model or selecting a catalog section.
FAQ
What formula does this simply supported center-load 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 center-load 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/eng/beam-ss-point-center-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/eng/beam-ss-point-center-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/eng/beam-ss-point-center-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/eng/beam-ss-point-center-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/eng/beam-ss-point-center-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": "eng.beam_ss_point_center_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 accepts those four finite numbers—load, length, elastic modulus, and moment of inertia—validates that load, span, and inertia are strictly positive and that modulus is non-zero, then returns the midspan deflection together with echoed inputs and fixed formula labels as structured JSON.
What simply supported center-load deflection means and when δ = PL³/(48EI) applies
Returning 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 programming languages without reimplementing the arithmetic.
How this calculator validates input and applies the midspan closed form
Load, length, and moment of inertia must be strictly positive so the load case and geometry remain physically meaningful for this product contract. There is no uniform distributed-load mode, no cantilever configuration, no fixed-end moment case, no off-center load position parameter, and no built-in unit conversion table; this capability is the midspan concentrated-load simply supported 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 deflection is returned, and failed validation is not charged against prepaid balance. Elastic modulus must be non-zero: zero modulus is explicitly rejected as invalid_input because it would divide by zero inside the classic formula, matching the engineering requirement that a beam with no stiffness cannot produce a finite deflection prediction. 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 without renaming fields. 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 and Worker isolates. The same pure function powers the free in-browser tool and the API path, with no network call, no random seed, and no wall-clock timestamp in the computation path, which keeps goldens and continuous-integration checks reliable.
Practical use, limits, pricing, and delivery channels for center-load beam checks
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, early-stage design worksheets, catalog section screeners, or preprocessing steps where you prefer explicit domain errors—such as rejecting zero elastic modulus or a zero span—over opaque widgets that cannot explain why a bad input was refused.
Integration use cases
Homework and exam verification
Students and graders compute midspan deflection for a simply supported beam under a center point load and receive a clear invalid_input error when modulus is zero or load, span, or inertia 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 runtime.