# Weld Calculator (Fillet Weld Groups, Eccentric Load, AISC) (`jumblemog/weld-calculator`) Actor

Fillet weld group calculator from plain text: throat area, centroid and J of weld patterns, direct, torsional and bending throat stress under eccentric and out-of-plane loads, AISC weld and base metal safety, and the smallest leg size that works.

- **URL**: https://apify.com/jumblemog/weld-calculator.md
- **Developed by:** [Jumble Mog](https://apify.com/jumblemog) (community)
- **Categories:** AI, Automation, Developer tools
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Weld Calculator (Fillet Weld Groups, Eccentric Load, AISC)

**Will the weld hold? Describe the joint in one line and find out.** Type `two vertical welds 100 mm long, 60 mm apart, 6 mm fillet, 10 kN at 150 mm eccentricity, E70` or `find the weld size: all around 50 x 100 mm, 20 kN cantilever 200 mm, safety 1.5`. You get back:

- **The weld group's properties**: throat area, centroid, the polar moment J and unit polar moment Ju, and the bending second moments Ix and Iy, treating the welds as lines (Shigley's method).
- **The throat stress at the most stressed point**: direct shear, torsional shear from an eccentric load or a torque, bending from a load out of the weld plane or a moment, and axial load, combined on the throat.
- **Safety factors** against the AISC allowables for the weld metal (0.30·Sut on the throat) and the base metal (0.40·Sy), and against yield.
- **The leg size a joint needs**: the smallest standard fillet that reaches your target safety, never below the AISC minimum for the plate thickness.
- **A chart**: the weld group to scale, coloured by throat stress, with the centroid, the load and the most stressed point, next to the safety factors.

Patterns: a single weld, two parallel welds (vertical or horizontal), L, C (three sides), box (all around a rectangle), circle (all around a round bar or tube), or any layout as a list of weld lines with their own leg sizes. Electrodes E60 to E120; base metals A36, A572, A992, S235, S275, S355, 1018, 1020, 304 and 6061-T6, or any yield strength. Metric (kN, mm, MPa) or inch (lbf, in, kpsi): results come back in the units you wrote.

It's made for:

- Mechanical and structural designers checking brackets, lugs, base plates and welded shafts.
- Fabricators deciding what fillet size to call out.
- Engineering students working Shigley-style weld group problems.
- AI agents that need real weld stresses instead of a guess.

![An L-shaped fillet weld group, 75 by 150 mm with an 8 mm leg, analyzed by this Actor: the welds drawn to scale and coloured by throat stress, with the centroid, a 25 kN load 100 mm from the centroid and the most stressed point at the end of the horizontal weld, next to bars of the safety factors 2.08 against the AISC weld allowable, 2.89 base metal and 3.27 against yield](https://api.apify.com/v2/key-value-stores/Km5b4PG3kYHdZSb1E/records/weld-calculator-example.png?signature=1frEKON8VUsWxnd6VkPhF)

### How to use it

1. Write **Weld groups**, one per entry. The form has examples.
2. Optionally set a default **electrode**, **base metal**, **target safety** or the **Units**.
3. Click **Start**. Each weld group is a row in the results, with its summary, chart and report.

#### Writing a weld group

| You write | It means |
|---|---|
| `single weld 100 mm long`, `two vertical welds 100 mm long, 60 mm apart`, `two horizontal welds 80 mm long 100 mm apart` | line welds |
| `L weld 75 x 150 mm`, `C weld b 3 in d 6 in`, `all around 50 x 100 mm` | L, C and box patterns (width x depth) |
| `all around a 50 mm diameter bar` | a circular weld |
| `6 mm fillet`, `1/4 in leg` | the leg size (all welds) |
| `10 kN`, `5000 lbf`, `horizontal load 8 kN`, `upward` | the load (downward unless told) |
| `150 mm eccentricity` | where the load acts, measured from the group's centroid |
| `120 mm from the welds` | where the load acts, measured from the right-hand edge of the welds |
| `cantilever 200 mm` | how far out of the weld plane the load acts (bending) |
| `torque 1 kN·m`, `moment 2 kN·m`, `15 kN axial` | other loads |
| `E70`, `E7018` | the electrode (E70 if not given) |
| `A36`, `S355`, `yield 250 MPa` | the base metal |
| `plate 10 mm`, `12 mm plate` | the thinner part, for the AISC minimum fillet size |
| `find the weld size ...` (or no leg), `safety 1.5` | size the leg for that safety |

Objects work too; see Input.

### Examples

All of these ran on this Actor; the numbers are from the results.

| Weld group | Result |
|---|---|
| `two vertical welds 100 mm long, 60 mm apart, 6 mm fillet, 10 kN at 150 mm eccentricity, E70` | Throat stress 66.3 MPa at the lower corner of the weld nearer the load; safety 2.18 against the AISC weld allowable |
| `find the weld size: all around 50 x 100 mm, 20 kN cantilever 200 mm, safety 1.5` | Needs a 7.11 mm leg, so an 8 mm fillet; bending 84.9 MPa plus 11.8 MPa direct shear; safety 1.69 |
| `1/4 in fillet, C weld b 3 in d 6 in, 5000 lbf, 8 in eccentricity, E70, A36` | Ju = 83.25 in³ as in Shigley's Table 9-1; 11.76 kpsi; the base metal governs at 1.74 |
| `all around a 50 mm diameter bar, torque 1 kN·m, 6 mm fillet` | Pure torsion: 60.0 MPa; safety 2.41 |
| `L weld 75 x 150 mm, 8 mm leg, 25 kN at 100 mm eccentricity, E70, S355` | 69.4 MPa at the end of the horizontal weld; safety 2.08 |
| `find the weld size: two vertical welds 150 mm long, 100 mm apart, 30 kN at 200 mm from the welds, 12 mm plate, safety 1.5` | Needs 8.46 mm, so a 10 mm fillet; safety 1.77 |

The tests check that:

- The group properties match Shigley's Tables 9-1 and 9-2 for every pattern (the circle within 0.05%).
- Eccentric, torsional, bending and axial loads give the hand-calculated throat stresses.
- Sizing picks the smallest standard leg that meets the target and the AISC minimum, in mm and in sixteenths of an inch.
- The text reader finds the pattern, sizes, leg, loads and materials.

### How-to examples

Each example is a complete input; the results are from runs of the Actor (also listed under **Examples**).

#### How to calculate the stress in an eccentrically loaded fillet weld group

```json
{"welds": ["two vertical welds 100 mm long, 60 mm apart, 6 mm fillet, 10 kN at 150 mm eccentricity, E70"]}
```

Result: 66.3 MPa throat stress at the lower corner of the weld nearer the load; safety 2.18 against the AISC weld allowable.

#### How to find the fillet weld size you need

```json
{"welds": ["find the weld size: all around 50 x 100 mm, 20 kN cantilever 200 mm, safety 1.5"]}
```

Result: a 7.11 mm leg, so an 8 mm fillet; 84.9 MPa from bending plus 11.8 MPa direct shear; safety 1.69.

#### How to check a weld in inch units with the base metal

```json
{"welds": ["1/4 in fillet, C weld b 3 in d 6 in, 5000 lbf, 8 in eccentricity, E70, A36"]}
```

Result: Ju = 83.25 in³ as in Shigley's Table 9-1; 11.76 kpsi; the A36 base metal governs at 1.74.

#### How to let an AI agent check welds

Add this Actor to the [Apify MCP server](https://mcp.apify.com) with `https://mcp.apify.com/?tools=jumblemog/weld-calculator`. The agent describes the weld pattern and load in one line and answers with the peak throat stress, where it is, and the safety factor or the leg size needed.

### FAQ

**Which weld patterns does it know?** A single weld, two parallel welds, L, C, box (all around a rectangle), circle (all around a bar or tube), or any layout as a list of weld lines with their own leg sizes.

**How is the strength checked?** Against AISC 360 allowables: 0.30·Sut of the electrode on the throat and 0.40·Sy of the base metal on the fusion face.

**Does it cover butt welds or fatigue?** No. Fillet welds under static loads only; groove, plug and slot welds and weld fatigue aren't covered.

**Is the line method conservative?** Yes. It ignores the extra strength of transversely loaded welds (AISC's directional factor and the instantaneous-center method).

### Input

| Field | What it is |
|---|---|
| `welds` | Weld groups, as text or objects. |
| `electrode` | Default electrode (E70). |
| `baseMetal` | Default base metal (S275, or A36 in inch units). |
| `safety` | Default target safety for sizing (1). |
| `units` | `mm` (kN and mm, default) or `in` (lbf and inches), for numbers written without a unit. |
| `charts` | Draw charts (default on). |

**A weld group as an object** takes:

- `pattern` (`single`, `two vertical`, `two horizontal`, `L`, `C`, `box`, `circle`) with `width`, `depth` or `diameter`; or `welds`: a list of `{x1, y1, x2, y2, leg}` lines for any layout.
- `leg`.
- `force` with `direction` (`down`, `up`, `horizontal`), or `fx` and `fy`.
- Where the load acts: `eccentricity` (from the centroid), `distanceFromWeld`, or `loadX` and `loadY` (in the welds' own coordinates); `lever` for out-of-plane distance.
- `axial`, `torque`, `moment`.
- `electrode`, `baseMetal` or `baseYield`, `plateThickness`.
- `mode` (`analyze` or `design`), `safety`, `units`, `title`, and `text` (a line of text, with the other fields overriding what it says).

### Output

One dataset item per weld group, also saved together in the run's `OUTPUT` record:

```json
{
  "request": 1, "status": "ok", "type": "weld", "mode": "analyze", "title": "Two vertical fillet weld group, 6 mm leg",
  "units": {"length": "mm", "force": "kN", "stress": "MPa", "moment": "N·m"},
  "group": {"pattern": "two vertical", "width": 60.0, "depth": 100.0, "leg": 6.0, "throat": 4.243,
            "weldLength": 200.0, "throatArea": 848.53, "centroidX": 30.0, "centroidY": 50.0,
            "polarMoment": 1470782.1, "unitPolarMoment": 346666.6667, "momentX": 707106.8, "momentY": 763675.3},
  "loads": {"fx": 0.0, "fy": -10.0, "atX": 150.0, "atY": 0.0, "torque": -1500.0},
  "critical": {"x": 60.0, "y": 0.0, "directShear": 11.79, "torsionShear": 59.47, "throatStress": 66.31},
  "strength": {"electrode": "E70", "allowableWeld": 144.6, "baseMetal": "S275", "allowableBase": 110.0},
  "safety": {"aiscWeld": 2.181, "aiscBase": 2.346, "yield": 3.42},
  "capacityFactor": 2.181,
  "imageUrl": "https://api.apify.com/v2/key-value-stores/.../records/001-....png"
}
```

Every item has `warnings`, `notes` (the formulas and assumptions), a Markdown `report` and links to the chart and report. A request that can't be computed has `"status": "failed"` and the reason in `error`, and isn't billed.

### How it works

1. **Reading**: each line is read for the pattern, sizes, leg, loads and materials; numbers carry their units.
2. **Group properties**: each weld is a line with a throat of 0.707·h; the throat area, centroid, Ix, Iy, Ixy and J = Ix + Iy are summed over the lines (Shigley section 9-3).
3. **Stresses**: at points along every weld, direct shear V/A, torsional shear T·r/J (T from the load's offset from the centroid plus any torque), bending M·c/I (from the load's lever out of the plane plus any moment, with unsymmetric bending when Ixy isn't zero) and axial load are added as vectors on the throat: τ = √(shear² + normal²).
4. **Strength**: AISC 360 allowables, 0.30·Sut of the electrode on the throat and 0.40·Sy of the base metal on the fusion face (0.707 of the throat stress), and yield at 0.577·Sy of the electrode.
5. **Sizing**: the stress falls in proportion to the leg, so the exact leg is the stress at a 1 mm leg times the target over the allowable; the result is rounded up to a standard size (3 to 25 mm, or 1/8 to 1 in by sixteenths), and to at least AISC Table J2.4's minimum.

Results are engineering estimates for the stated assumptions; for building and pressure work, follow the code your project uses (AISC, AWS D1.1, Eurocode 3), including its load factors and inspection rules.

### Pricing

You pay one low price per weld group, at the price shown on this page. It includes the chart and the report. Requests that can't be computed are never charged. If you set a maximum cost per run, the Actor stops before a request that wouldn't fit.

### Speed

A weld group takes a few milliseconds, plus the chart. A run through the API answers in about 5 to 10 seconds, including the cloud container starting.

### Tips and limits

- **Fillet welds only**: groove (butt) welds, plug and slot welds aren't covered.
- **Static loads**: fatigue of welded joints (detail categories, stress ranges) isn't checked.
- **The line method is conservative**: it ignores the extra strength of welds loaded transversely (AISC's directional factor and the instantaneous-center method).
- **Load position**: `eccentricity` is measured from the group's centroid; use `distanceFromWeld` or `loadX`/`loadY` when you know the distance from the welds instead.
- **Limits**: 500 weld groups per run.

### For AI agents and developers

This Actor works with the [Apify MCP server](https://mcp.apify.com), so AI agents can call it as a tool. Pass `welds` as plain text and read `summary`, `critical`, `safety`, `design` and `warnings`. A direct API call that waits for the answer:

```bash
curl -X POST "https://api.apify.com/v2/acts/jumblemog~weld-calculator/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"welds": ["find the weld size: C weld 80 x 160 mm, 18 kN at 250 mm from the welds, 10 mm plate, safety 1.5"]}'
```

`run-sync` instead returns the run's `OUTPUT`: the status, the counts and every result as JSON.

In Python, with the `apify-client` package:

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_TOKEN")
run = client.actor("jumblemog/weld-calculator").call(run_input={
    "welds": [{"title": "Bracket on a column",
               "welds": [{"x1": 0, "y1": 0, "x2": 0, "y2": 150}, {"x1": 0, "y1": 0, "x2": 100, "y2": 0}],
               "leg": "8 mm", "force": "30 kN", "loadX": "250 mm", "loadY": "150 mm",
               "electrode": "E70", "baseMetal": "S355", "plateThickness": "12 mm"}],
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["summary"])
```

### Credits

- Charts: [Vega-Lite](https://vega.github.io/vega-lite/) and [vl-convert](https://github.com/vega/vl-convert) (BSD-3-Clause), with the [Inter](https://rsms.me/inter/) font (SIL Open Font License).
- Method: Budynas and Nisbett, *Shigley's Mechanical Engineering Design*, chapter 9, with AISC 360 allowable stresses and minimum fillet sizes and AWS electrode strengths.

# Actor input Schema

## `welds` (type: `array`):

One weld group per entry, as a line of text or an object. Give the pattern ('single', 'two vertical welds', 'two horizontal welds', 'L weld', 'C weld' (three sides), 'all around 50 x 100 mm' (box), 'all around a 50 mm diameter bar' (circle)) with its sizes ('100 mm long, 60 mm apart', 'b 3 in d 6 in'), the leg ('6 mm fillet', '1/4 in leg') and the load ('10 kN', '5000 lbf', 'horizontal load 8 kN') with where it acts ('150 mm eccentricity' from the centroid, '120 mm from the welds', 'cantilever 200 mm' out of the weld plane). Also 'torque 1 kN·m', 'moment 2 kN·m', '15 kN axial', the electrode ('E70'), the base metal ('A36', 'S355', or 'yield 250 MPa'), 'plate 10 mm' for the AISC minimum size and 'safety 1.5'. Without a leg (or with 'find the weld size') it picks the smallest standard fillet. Object fields: mode, pattern, width, depth, diameter, leg, welds (list of x1, y1, x2, y2, optional leg, for any layout), force, direction, fx, fy, eccentricity, distanceFromWeld, loadX, loadY (where the load acts, in the welds' coordinates), lever, axial, torque, moment, electrode, baseMetal, baseYield, plateThickness, safety, units, title.

## `electrode` (type: `string`):

E70 if unset.

## `baseMetal` (type: `string`):

S275 (metric) or A36 (inch) if unset. Sets the base metal shear allowable 0.40·Sy.

## `safety` (type: `string`):

The safety factor over the AISC allowables a sized weld must reach, such as '1.5'. 1 if unset (the AISC allowables already hold a margin).

## `units` (type: `string`):

For numbers written without a unit. lbf or inches in the text switch to inch units on their own.

## `charts` (type: `boolean`):

The weld group to scale, coloured by throat stress, with the load and the most stressed point, and the safety factors.

## Actor input object example

```json
{
  "welds": [
    "two vertical welds 100 mm long, 60 mm apart, 6 mm fillet, 10 kN at 150 mm eccentricity, E70",
    "find the weld size: all around 50 x 100 mm, 20 kN cantilever 200 mm, safety 1.5",
    "1/4 in fillet, C weld b 3 in d 6 in, 5000 lbf, 8 in eccentricity, E70, A36",
    {
      "title": "Bracket on a column",
      "welds": [
        {
          "x1": 0,
          "y1": 0,
          "x2": 0,
          "y2": 150
        },
        {
          "x1": 0,
          "y1": 0,
          "x2": 100,
          "y2": 0
        }
      ],
      "leg": "8 mm",
      "force": "30 kN",
      "loadX": "250 mm",
      "loadY": "150 mm",
      "electrode": "E70",
      "baseMetal": "S355",
      "plateThickness": "12 mm"
    }
  ],
  "units": "mm",
  "charts": true
}
```

# Actor output Schema

## `results` (type: `string`):

One row per weld group: the summary and chart.

## `output` (type: `string`):

The OUTPUT record: every result in one JSON object.

## `files` (type: `string`):

Charts (PNG and SVG) and Markdown reports in the run's key-value store.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "welds": [
        "two vertical welds 100 mm long, 60 mm apart, 6 mm fillet, 10 kN at 150 mm eccentricity, E70",
        "find the weld size: all around 50 x 100 mm, 20 kN cantilever 200 mm, safety 1.5",
        "1/4 in fillet, C weld b 3 in d 6 in, 5000 lbf, 8 in eccentricity, E70, A36",
        {
            "title": "Bracket on a column",
            "welds": [
                {
                    "x1": 0,
                    "y1": 0,
                    "x2": 0,
                    "y2": 150
                },
                {
                    "x1": 0,
                    "y1": 0,
                    "x2": 100,
                    "y2": 0
                }
            ],
            "leg": "8 mm",
            "force": "30 kN",
            "loadX": "250 mm",
            "loadY": "150 mm",
            "electrode": "E70",
            "baseMetal": "S355",
            "plateThickness": "12 mm"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("jumblemog/weld-calculator").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "welds": [
        "two vertical welds 100 mm long, 60 mm apart, 6 mm fillet, 10 kN at 150 mm eccentricity, E70",
        "find the weld size: all around 50 x 100 mm, 20 kN cantilever 200 mm, safety 1.5",
        "1/4 in fillet, C weld b 3 in d 6 in, 5000 lbf, 8 in eccentricity, E70, A36",
        {
            "title": "Bracket on a column",
            "welds": [
                {
                    "x1": 0,
                    "y1": 0,
                    "x2": 0,
                    "y2": 150,
                },
                {
                    "x1": 0,
                    "y1": 0,
                    "x2": 100,
                    "y2": 0,
                },
            ],
            "leg": "8 mm",
            "force": "30 kN",
            "loadX": "250 mm",
            "loadY": "150 mm",
            "electrode": "E70",
            "baseMetal": "S355",
            "plateThickness": "12 mm",
        },
    ] }

# Run the Actor and wait for it to finish
run = client.actor("jumblemog/weld-calculator").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "welds": [
    "two vertical welds 100 mm long, 60 mm apart, 6 mm fillet, 10 kN at 150 mm eccentricity, E70",
    "find the weld size: all around 50 x 100 mm, 20 kN cantilever 200 mm, safety 1.5",
    "1/4 in fillet, C weld b 3 in d 6 in, 5000 lbf, 8 in eccentricity, E70, A36",
    {
      "title": "Bracket on a column",
      "welds": [
        {
          "x1": 0,
          "y1": 0,
          "x2": 0,
          "y2": 150
        },
        {
          "x1": 0,
          "y1": 0,
          "x2": 100,
          "y2": 0
        }
      ],
      "leg": "8 mm",
      "force": "30 kN",
      "loadX": "250 mm",
      "loadY": "150 mm",
      "electrode": "E70",
      "baseMetal": "S355",
      "plateThickness": "12 mm"
    }
  ]
}' |
apify call jumblemog/weld-calculator --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,jumblemog/weld-calculator"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/531BKpcXBj6PnrPUT/builds/nCvELha9oubKOPPTB/openapi.json
