Beam & Frame Calculator: Shear, Moment, Deflection

Analyze beams, 2D frames and trusses in one call, written the way an engineer says them. Describe a beam in plain text, such as 6 m, pin at 0, roller at 6 m, 20 kN at 2 m and 5 kN/m. Or give a frame or truss as nodes, members and loads in JSON. Each structure comes back with:

• Support reactions.
• Shear force, bending moment, axial force, deflection and rotation along every member.
• The largest values and where they occur.
• A bending stress check against the material's strength.
• A deflection check against a span limit such as L/360.
• Diagrams as PNG and SVG, the full data as CSV, a Markdown report and JSON.

The calculator reads SI and US units (kN, kN/m, kNm, mm, MPa, kip, plf, kip-ft, in, ksi), common sections (I-beams, channels, rectangles, tubes, boxes, 2x10 lumber, or your own I and A) and materials (S355, A992, aluminum 6061, C24 timber, Douglas fir, concrete and more). It also handles internal hinges, overhangs, continuous beams, linearly varying loads, applied moments and self-weight.

It's made for engineering students checking homework, builders and DIYers sizing a joist or a lintel, engineers who want a quick independent check, developers who need a beam solver behind an API, and AI agents that should compute a structure instead of guessing at it.

What it does

• Beams:
  • Supports: simply supported, cantilever, fixed at both ends, propped cantilever, or any mix of pins, rollers and fixed supports at any position. A beam on three or more supports is a continuous beam.
  • Loads: point loads, uniform loads over the whole beam or part of it, triangular and trapezoidal loads, applied moments, and axial loads.
  • Hinges inside the beam, for Gerber beams.
• Frames and trusses:
  • Nodes at any x and y, with supports: pin, roller, fixed or guided.
  • Members with their own section and material, rigid or pinned at either end.
  • Loads on nodes (forces and moments) and loads along members, in global or member axes.
  • Set truss: true and every member is pin-ended, so it carries axial force only.
• Results:
  • Reactions at each support.
  • The largest shear, sagging and hogging moments, deflection or displacement, rotation, tension and compression, each with where it occurs.
  • The stress use of each member: stress over strength.
  • Deflection per span against your limit, with cantilevers checked at twice their length.
  • For frames, a table of members.
• Diagrams:
  • For a beam, four panels on one axis: the loads and reactions, shear, moment and deflection.
  • For a frame, the deformed shape and the moment drawn on the tension side, at true proportions. A truss gets its axial forces, colored by tension or compression, in place of the moment.
• Clear errors: an unstable layout (one support, a hinge that makes a mechanism, a truss panel without a diagonal) is reported with what to add, and isn't billed.
• Batches: up to 100 structures per run. Shared section, material and units apply to every entry that doesn't set its own.

Who it's for

• Students of statics, mechanics of materials and structural analysis, to check hand calculations and see the diagrams.
• Builders, carpenters and DIYers sizing a deck joist, header or shelf, with US lumber sizes and loads in plf.
• Engineers who want a quick independent check of a beam or a small frame, in a report they can paste anywhere.
• Developers of calculators, estimating tools and educational apps that need a structural solver behind an API.
• AI agents asked "what size beam do I need" or "draw the shear and moment diagram": one call returns exact numbers and a picture.

How to use it

1. Set the Beam length, such as 6 m or 20 ft.
2. Add Supports: simply supported, cantilever, or lines such as pin at 0 and roller at 6 m.
3. Add Loads, one per line: 20 kN at 2 m, 5 kN/m, 0 to 8 kN/m from 0 to 6 m, 4 kNm clockwise at 3 m.
4. Pick the Cross-section and Material (or keep the default steel I-beam).
5. Click Start. Open the diagram and the report from the results table.

For a frame or truss, fill Frame or truss (JSON) instead of the beam fields.

Examples

All three below ran on this Actor; the numbers are from the results.

A steel beam with an overhang (the picture above): 8 m, pin at 0, roller at 6 m, loads 12 kN/m, 30 kN at 2.5 m and 20 kN at 8 m, section I 300 x 150 x 10.7 x 7.1 mm, material S355.

Reactions: pin at 0 m: 42.83 kN up; roller at 6 m: 103.2 kN up. Largest moment: 69.58 kN·m at x = 2.5 m and -64 kN·m at x = 6 m. Largest shear: 59.17 kN at x = 6 m. Largest deflection: 11.43 mm down at x = 2.66 m. Bending stress uses 37% of the material's strength. Deflection L/525 (within L/360).

A wood deck joist in US units: 14 ft, simply supported, 80 plf, section 2x10, material douglas fir, with self-weight.

Reactions: pin at 0 ft: 0.5823 kip up; roller at 14 ft: 0.5823 kip up. Largest moment: 2.038 kip·ft at x = 7 ft. Largest shear: 0.5823 kip at x = 14 ft. Largest deflection: 0.4556 in down at x = 7 ft. Bending stress uses 127% of the material's strength (over it). Deflection L/369 (within L/360).

The 127% compares the stress with the reference bending value of No. 2 Douglas fir (900 psi), before the size and repetitive-member factors a design code would apply. That's why the stress check is a screen, not a design check.

A portal frame with fixed bases, 4 m tall and 6 m wide, with 10 kN of wind at the top left and 8 kN/m on the roof beam:

{
  "nodes": [
    {"id": "A", "x": 0, "y": 0, "support": "fixed"},
    {"id": "B", "x": 0, "y": 4},
    {"id": "C", "x": 6, "y": 4},
    {"id": "D", "x": 6, "y": 0, "support": "fixed"}
  ],
  "members": [
    {"id": "1", "from": "A", "to": "B"},
    {"id": "2", "from": "B", "to": "C"},
    {"id": "3", "from": "C", "to": "D"}
  ],
  "loads": [{"node": "B", "fx": 10}, {"member": "2", "w": -8}]
}

Reactions: fixed at A: 21.34 kN up, 1.706 kN right, 3.138 kN·m counterclockwise; fixed at D: 26.66 kN up, 11.71 kN left, 20.88 kN·m counterclockwise. Largest moment: 20.88 kN·m in member 3 and -25.94 kN·m in member 3. Largest shear: 26.66 kN in member 2. Largest displacement: 4.202 mm at (2.791 m, 4 m). Largest compression: 26.66 kN in member 3. The most stressed member uses 15% of the material's strength.

How-to examples

These are the examples under Examples above, written as complete inputs; the result lines are from their runs.

How to calculate beam reactions, shear and bending moment

{"length": "8 m", "supports": ["pin at 0", "roller at 6 m"], "loads": ["12 kN/m", "30 kN at 2.5 m", "20 kN at 8 m"],
 "section": "I 300 x 150 x 10.7 x 7.1 mm", "material": "S355"}

Result: "Reactions: pin at 0 m: 42.83 kN up; roller at 6 m: 103.2 kN up. Largest moment: 69.58 kN·m at x = 2.5 m and -64 kN·m at x = 6 m. Largest shear: 59.17 kN at x = 6 m. Largest deflection: 11.43 mm down at x = 2.66 m..." with shear, moment and deflection diagrams.

How to check the deflection of a wood joist

{"length": "14 ft", "supports": ["simply supported"], "loads": ["80 plf"], "section": "2x10", "material": "douglas fir", "selfWeight": true}

Result: "Largest moment: 2.038 kip·ft at x = 7 ft... Largest deflection: 0.4556 in down at x = 7 ft... Deflection L/369 (within L/360)." The stress line compares the stress with the wood's reference bending value, before design-code factors, so treat it as a screen.

How to analyze a 2D portal frame or truss

Give nodes, members and loads in frame, as in the portal frame example above (fixed bases, 4 m by 6 m, 10 kN of wind and 8 kN/m on the roof). Result: "Reactions: fixed at A: 21.34 kN up, 1.706 kN right, 3.138 kN·m counterclockwise; fixed at D: 26.66 kN up, 11.71 kN left, 20.88 kN·m counterclockwise..." with each member's forces and the largest displacement.

How to let an AI agent check a beam

Add this Actor to the Apify MCP server with https://mcp.apify.com/?tools=jumblemog/beam-calculator. The agent writes supports and loads the way an engineer says them ("pin at 0", "20 kN at 2 m") and passes on the reactions, moments and deflection instead of working them out by hand.

FAQ

What can it analyze? Beams with any supports, overhangs and hinges, continuous beams, 2D frames and trusses, with point loads, distributed and varying loads, and moments.

Which units does it use? Metric or US. Each value can carry its unit (kN/m, plf, ft), or set units.

Which sections and materials does it know? I-beams, channels, rectangles, tubes and boxes by their dimensions, 2x10 style lumber, or your own I and A, with materials such as S355, A992, aluminum 6061, C24 timber, Douglas fir and concrete.

Is it a design check? No. It gives the analysis and a stress and deflection screen. Code checks need the factors of your design code; see the steel and wood member calculators for those.

Does it work with Zapier, Make or n8n? Yes. Call the Actor with its Apify app or an HTTP request and pass the results on.

Input

Field	What it is
length	The beam's length with a unit: 6 m, 4500 mm, 20 ft.
supports	simply supported (default), cantilever, fixed both ends, propped cantilever, or lines like pin at 0, roller at 6 m, fixed at end, roller at L/2.
loads	One per line, downward unless it says up. Examples: 10 kN at 3 m, 5 kN/m, 5 kN/m from 1 to 4 m, 2 to 8 kN/m from 0 to 6 m, 4 kNm clockwise at 2 m, 15 kN horizontal at end. Positions can be mid, end, L/3.
hinges	Internal hinges: at 4 m.
section	rectangle 100 x 200 mm (width x depth), square 50 mm, circle 40 mm, tube 60.3 x 4 mm, box 100 x 50 x 5 mm, I 300 x 150 x 10.7 x 7.1 mm (depth x width x flange x web), channel ..., 2x10, or I = 8360 cm4, A = 53.8 cm2, depth = 300 mm.
material	steel, S235/S275/S355, A36, A992, A500, stainless, aluminum/6061/6063, timber, C16, C24, glulam, douglas fir, spf, southern pine, concrete, titanium, copper, pvc, plywood, or E = 200 GPa, fy = 355 MPa.
selfWeight	Add the member's own weight (default false).
deflectionLimit	The span limit as L/n: 360 (default), 240, 180...
units	auto (default), SI or US. Sets the unit of bare numbers and of the results.
frame	A frame or truss: nodes (id, x, y, support), members (id, from, to, optional section, material, release: start, end or both), loads ({"node", "fx", "fy", "moment"} or {"member", "w", "w2", "wx", "wLocal", "from", "to"}), optional truss, section, material, selfWeight. Coordinates in m (ft in US units), y up. Loads are in global axes, so downward is negative.
structures	Several structures in one run: a list of objects with the fields above.
title	A title for the results and files.
dataPoints	Diagram points included in each result (default 200). The CSV has them all.

Sign conventions: upward and rightward forces and counterclockwise moments are positive in reactions and frame loads. A beam's applied moment is clockwise unless it says counterclockwise. Positive bending moment is sagging (tension at the bottom), positive shear follows the moment's slope, and axial force is positive in tension.

Output

One dataset item per structure, also saved together in the run's OUTPUT record (shortened):

{
  "title": "Steel floor beam with an overhang",
  "status": "solved",
  "kind": "beam",
  "units": "SI",
  "unitLabels": {"length": "m", "force": "kN", "moment": "kN·m", "line": "kN/m", "stress": "MPa", "deflection": "mm"},
  "section": {"name": "I-section I 300 x 150 x 10.7 x 7.1 mm (depth x width x flange x web)", "area": 5188.1, "inertia": 79990000.0, "modulus": 533270.0},
  "material": {"name": "Steel S355", "E": 210000.0, "strength": 355.0},
  "reactions": [
    {"node": "x=0", "x": 0.0, "y": 0.0, "support": "pin", "fx": 0.0, "fy": 42.833, "moment": 0.0},
    {"node": "x=6", "x": 6.0, "y": 0.0, "support": "roller", "fx": 0.0, "fy": 103.17, "moment": 0.0}
  ],
  "maxima": {
    "shear": {"value": -59.167, "x": 6.0},
    "momentPositive": {"value": 69.583, "x": 2.5},
    "momentNegative": {"value": -64.0, "x": 6.0},
    "rotation": {"value": -0.0067432, "x": 0.0},
    "deflection": {"value": -11.429, "x": 2.66}
  },
  "checks": {
    "deflectionLimit": "L/360",
    "spans": [
      {"from": 0.0, "to": 6.0, "cantilever": false, "deflection": -11.429, "at": 2.66, "allowed": 16.667, "ratio": "L/525", "ok": true},
      {"from": 6.0, "to": 8.0, "cantilever": true, "deflection": 1.0054, "at": 6.92, "allowed": 11.111, "ratio": "L/3979", "ok": true}
    ],
    "bendingStressOk": true, "deflectionOk": true, "maxUtilization": 0.3676
  },
  "diagram": [{"x": 0.0, "shear": 42.833, "moment": 0.0, "deflection": 0.0, "rotation": -0.0067432}, "..."],
  "equilibriumError": 4.79e-09,
  "summary": "Reactions: pin at 0 m: 42.83 kN up; roller at 6 m: 103.2 kN up. Largest moment: 69.58 kN·m at x = 2.5 m ...",
  "imageUrl": "https://api.apify.com/v2/key-value-stores/.../records/structure-001-Steel-floor-beam-with-an-overhang.png",
  "svgUrl": "...", "csvUrl": "...", "markdownUrl": "...", "jsonUrl": "...",
  "report": "# Steel floor beam with an overhang\n\n...",
  "notes": []
}

Frames also have members: each member's length, largest moment and shear, axial force, deflection, stress and use. In frames, maxima has displacement, axialTension and axialCompression, and each place is given as member, distance along it and x, y. A structure that can't be solved has "status": "failed" and the reason in error, and isn't billed.

How it works

1. The text is read into numbers in SI units: lengths, forces, line loads and moments with their units, positions like mid or L/3, and sections and materials from built-in tables.
2. The structure becomes a 2D frame model: beam nodes at supports, hinges and load ends, members with Euler-Bernoulli bending and axial stiffness. Each member is cut into short elements, about 400 for a beam, so the diagrams are smooth.
3. Distributed loads become consistent nodal loads, and the stiffness matrix is solved with NumPy. A hinge gets its own rotation, and a structure that can move freely is caught from the stiffness matrix's condition number before solving.
4. Shear, moment and axial force come from each element's end forces. The displacements are exact at every element end, and the reactions are checked against the loads (equilibriumError).
5. The diagrams are drawn with Vega-Lite and rendered to PNG and SVG with vl-convert.

Pricing

You pay per structure analyzed, at the price shown on this page, with every file included. Structures that can't be solved are never charged. If you set a maximum cost per run, the Actor stops before a structure that wouldn't fit.

Speed

A beam or a small frame solves in well under a second. A large frame of a few hundred members takes a few seconds. A run through the API answers in about 5 to 10 seconds, including the cloud container starting and the files being saved.

Tips and limits

• This is an elastic analysis, not a design-code check. It doesn't check buckling of columns or compression members, lateral-torsional buckling, shear, bearing, vibration or connections. It applies no load factors or combinations. Have a qualified engineer design anything people rely on.
• The stress check compares the largest bending plus axial stress with the material's yield strength for metals, or its reference bending value for timber, without code factors. Concrete has no strength value, because a cracked section needs a real design.
• Small deflections are assumed. When a displacement passes 1/50 of the structure's size, a note says the numbers are a sign of overload rather than accurate values.
• Point loads on frame members aren't supported. Add a node where the load acts and split the member there.
• Units: a bare number takes the system's default unit (m, kN, kN/m, kN·m in SI; ft, kip, kip/ft, kip·ft in US). With auto, US is picked when most of the units you write are US units.
• Limits: beams up to 1000 m, frames up to 300 nodes and 500 members, 100 structures per run.

For AI agents and developers

This Actor works with the Apify MCP server, so AI agents can call it as a tool: pass length, supports and loads as text (or a frame), and read summary, reactions, maxima, checks and imageUrl from the result. A direct API call that waits for the answer:

curl -X POST "https://api.apify.com/v2/acts/jumblemog~beam-calculator/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"length": "6 m", "supports": ["pin at 0", "roller at 6 m"], "loads": ["5 kN/m", "20 kN at 2 m"], "section": "I 300 x 150 x 10.7 x 7.1 mm", "material": "S355"}'

run-sync instead returns the run's OUTPUT: the status, how many structures were solved and every result as JSON.

In Python, with the apify-client package:

from apify_client import ApifyClient

client = ApifyClient("YOUR_TOKEN")
run = client.actor("jumblemog/beam-calculator").call(run_input={
    "units": "US",
    "structures": [
        {"title": "Deck joist", "length": "14 ft", "loads": ["80 plf"], "section": "2x10", "material": "douglas fir"},
        {"title": "Header", "length": "8 ft", "loads": ["450 plf"], "section": "rectangle 3.5 x 9.25 in", "material": "douglas fir"},
    ],
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["title"], item["summary"], item["imageUrl"])

Credits

• Solving: NumPy (BSD-3-Clause).
• Diagrams: Vega-Lite and vl-convert (BSD-3-Clause), with the Inter font (SIL Open Font License).