# Bolted Joint Calculator (Preload, Torque, Safety Factors) (`jumblemog/bolted-joint-calculator`) Actor

Bolted joint calculator from plain text: preload and tightening torque, bolt and joint stiffness, bolt load, safety against yield, separation, fatigue and slip, bolt length, and bolt sizing. Metric and inch, ISO, SAE and ASTM grades.

- **URL**: https://apify.com/jumblemog/bolted-joint-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

## Bolted Joint Calculator (Preload, Torque, Safety Factors)

**Will the bolts hold? Describe the joint in one line and find out.** Type `M12 8.8 bolt, 2 x 15 mm steel, 10 kN per bolt` or `1/2-13 UNC grade 5, 1.5 in steel + 0.5 in aluminum, 2000 lbf per bolt, lubricated`. You get back:

- **The preload and tightening torque**: 75% of the proof load for a reusable joint (90% for a permanent one), or your own preload, percentage or torque. Torque comes from the torque coefficient K for the finish, or from a friction coefficient by the VDI 2230 formula.
- **The joint stiffness**: bolt stiffness from its shank and threaded lengths in the grip, member stiffness from 30° pressure cones through each clamped part, and the joint constant C (the share of the load the bolt takes).
- **What the load does**: the bolt load and stress, the clamp left on the parts, and the load that would open the joint.
- **Safety factors**: against yielding (proof), overload (load factor), separation, fatigue (Goodman, with endurance strengths for rolled threads), and slip under shear, plus bolt shear if it slips.
- **The bolt to order**: the standard length that leaves two threads past the nut, or engages enough thread in a tapped hole for the material.
- **For design requests**: the standard sizes and grades are tried and the smallest bolt meeting your safety targets comes back, with others that work.
- **A chart**: the classic joint diagram (bolt and clamped parts, force against stretch, with the preload and the load marked) next to the safety factors.

It covers:

- **Threads**: ISO metric coarse and fine (M1.6 to M48, any pitch) and Unified UNC/UNF (#4 to 1-1/2 in).
- **Grades**: ISO 4.6, 4.8, 5.8, 8.8, 9.8, 10.9 and 12.9; SAE grades 1, 2, 4, 5, 7 and 8; ASTM A307, A325 and A490; stainless A2-50, A2-70 and A4-80.
- **Clamped parts**: any stack of steel, stainless, aluminum, cast and ductile iron, brass, copper, bronze, titanium, magnesium, zinc, or any part with its own E (a gasket, a plastic).
- **Through bolts with nuts, and cap screws** into a tapped part, with or without washers.

It's made for:

- Mechanical and design engineers checking flanges, brackets, housings and machine frames.
- Maintenance and assembly teams that need a torque value and a bolt length.
- Students working Shigley-style bolted joint problems.
- AI agents that need real joint numbers instead of a guess.

![A flange held by six M10 class 10.9 cap screws into cast iron, analyzed by this Actor: the joint diagram with the preload at 36 kN and the 10 kN load per bolt split between the bolt and the clamp, and safety factors of 1.20 against proof, 2.98 load factor, 6.05 against separation and 1.62 in fatigue](https://api.apify.com/v2/key-value-stores/Km5b4PG3kYHdZSb1E/records/bolted-joint-calculator-example.png?signature=1eN1XmkztABcmmVp0yICm)

### How to use it

1. Write **Joints**, one per entry. The form has examples.
2. Optionally set a **Default grade**, **Default finish** or the **Units** for numbers without one.
3. Click **Start**. Each joint is a row in the results, with its summary, chart and report.

#### Writing a joint

| You write | It means |
|---|---|
| `M12`, `M10x1.25`, `M8 fine`, `1/2-13 UNC`, `3/8 UNF`, `#10-24` | the thread |
| `8.8`, `class 10.9`, `grade 5`, `SAE 8`, `A325`, `A2-70` | the grade (8.8 or grade 5 if left out) |
| `2 x 15 mm steel`, `20 mm aluminum + 10 mm steel`, `steel plate 12 mm` | the clamped parts |
| `cap screws into cast iron`, `into a tapped hole in aluminum` | a tapped hole |
| `6 bolts`, `6 x M10` | the bolt count |
| `60 kN total tension`, `10 kN per bolt`, `2000 lbf` | the tension (a total is shared by the bolts) |
| `0 to 60 kN`, `2 to 8 kN`, `cyclic` | a fluctuating load, for fatigue |
| `8 kN shear`, `slip factor 0.3` | a shear load, for slip |
| `lubricated`, `zinc`, `black`, `cadmium`, `anti-seize`, `friction 0.12`, `K = 0.15` | how torque turns into preload |
| `preload 70%`, `preload 30 kN`, `torque 50 N·m`, `permanent` | the preload |
| `washers`, `washer 2 mm`, `length 60 mm`, `safety 2` | washers, a bolt length to check, the design target |
| `design ...`, or no size | find the bolt |

Objects work too; see Input.

### Examples

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

| Joint | Result |
|---|---|
| `M12 8.8 bolt, 2 x 15 mm steel, 10 kN per bolt` | Preload 36.7 kN at 88 N·m; C = 0.211; the bolt carries 38.8 kN (460 MPa); load factor 5.80, separation safety 4.64; a 45 mm bolt |
| `6 x M10 10.9 cap screws into cast iron, 20 mm aluminum flange, 0 to 60 kN total tension, cyclic` | Preload 36.1 kN at 72 N·m; C = 0.403 (the soft aluminum flange takes less of the load); load factor 2.98, separation 6.05, fatigue 1.62; 35 mm screws |
| `1/2-13 UNC grade 5, 1.5 in steel + 0.5 in aluminum, 2000 lbf per bolt, lubricated` | Preload 9046 lbf at 67.9 lbf·ft; C = 0.268; load factor 5.62, separation 6.18; a 2-3/4 in bolt |
| `design bolts: 4 bolts, 40 kN tension, 8 kN shear, 2 x 12 mm steel plates, safety 2` | M8 class 12.9: load factor 4.60, separation 3.30, slip 1.86; 42.6 N·m |
| Pump flange: 8 x M16 8.8, 20 mm steel + 3 mm gasket (E 0.5 GPa) + 20 mm steel, 120 kN, lubricated | The soft gasket makes C = 0.78, so the bolts see most of the load: load factor 1.94 |
| `M20 4.6, 2 x 8 mm steel, 50 kN` | Load factor 0.95 and proof safety 0.99: warnings say the bolt yields and the separation margin is thin |

The tests check that:

- Tensile stress areas match the ISO 898-1 and ASME tables (M10 58.0 mm², M20 245 mm², 1/2-13 0.1419 in², 1/2-20 0.1599 in²).
- Member stiffness matches Shigley's closed form (eq. 8-22) for two equal plates, and splitting a part into layers doesn't change it.
- Bolt stiffness, bolt load, load factor, separation factor, Goodman fatigue (eq. 8-38) and torque match their formulas.
- Tapped holes, inch threads, totals shared by the bolts, load ranges, shear and design are read and handled correctly.

### How-to examples

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

#### How to calculate bolt preload, tightening torque and joint safety

```json
{"joints": ["M12 8.8 bolt, 2 x 15 mm steel, 10 kN per bolt"]}
```

Result: preload 36.7 kN at 88 N·m; joint constant C = 0.211; the bolt carries 38.8 kN (460 MPa); load factor 5.80 and separation safety 4.64; a 45 mm bolt.

#### How to check bolt fatigue in a flange under cyclic load

```json
{"joints": ["6 x M10 10.9 cap screws into cast iron, 20 mm aluminum flange, 0 to 60 kN total tension, cyclic"]}
```

Result: preload 36.1 kN at 72 N·m; C = 0.403; load factor 2.98, separation 6.05 and Goodman fatigue safety 1.62; 35 mm screws.

#### How to choose the bolt size for a tension and shear load

```json
{"joints": ["design bolts: 4 bolts, 40 kN tension, 8 kN shear, 2 x 12 mm steel plates, safety 2"]}
```

Result: M8 class 12.9: load factor 4.60, separation 3.30, slip 1.86, tightened to 42.6 N·m.

#### How to let an AI agent check bolted joints

Add this Actor to the [Apify MCP server](https://mcp.apify.com) with `https://mcp.apify.com/?tools=jumblemog/bolted-joint-calculator`. The agent describes the joint in one line and answers with the preload, torque and safety factors.

### FAQ

**Does it take inch threads?** Yes: `1/2-13 UNC grade 5, 1.5 in steel + 0.5 in aluminum, 2000 lbf per bolt, lubricated` gives 9046 lbf preload at 67.9 lbf·ft, and the results come back in inch units.

**Does a gasket change the result?** Yes. Each layer has its own stiffness, so a soft gasket raises the joint constant and the bolts see more of the load.

**Which grades have fatigue checks?** ISO 8.8 to 12.9, SAE 5, 7 and 8, A325 and A490, from Shigley's endurance strengths for rolled threads.

**How exact is the torque?** Torque control scatters the real preload by ±25% or more. For critical joints, control the preload more closely and confirm with the full VDI 2230 method.

### Input

| Field | What it is |
|---|---|
| `joints` | Joints, as text or objects. |
| `grade` | Default grade. |
| `finish` | Default finish (sets K). |
| `units` | `mm` (default) or `in`, for numbers written without a unit. |
| `charts` | Draw charts (default on). |

**A joint as an object** takes:

- `size`, `grade`, `count`, `mode` (`analyze` or `design`).
- `members`: a list of `{"thickness": "20 mm", "material": "aluminum"}` or `{"thickness": "3 mm", "E": "0.5 GPa"}`; or `grip` for one steel part.
- `tapped` (true for cap screws) and `tappedMaterial`.
- `load` (tension), `minLoad`, `cyclic`, `shear`, `perBolt` (otherwise a load is the total for all the bolts).
- `preload`, `preloadPercent`, `torque`, `permanent`, `finish`, `friction`, `nutFactor`.
- `slipFriction` (0.2), `shearPlanes` (1), `safety` (2, the design target for the load factor), `washer`, `length`, `units`, `title`.
- `text`: a line of text, with the other fields overriding what it says.

### Output

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

```json
{
  "request": 2, "status": "ok", "type": "joint", "mode": "analyze", "title": "M10x1.5 class 10.9 cap screw x 6",
  "units": {"length": "mm", "force": "kN", "stress": "MPa", "stiffness": "kN/mm", "torque": "N·m", "area": "mm²"},
  "bolt": {"size": "M10x1.5", "tensileStressArea": 57.99, "grade": "ISO class 10.9", "proofStrength": 830,
           "proofLoad": 48.1313, "length": 35, "threadInGrip": 16.0, "count": 6, "type": "cap screw"},
  "joint": {"members": [{"thickness": 20.0, "material": "Aluminum", "E": 71000}], "tappedMember": "Gray cast iron",
            "grip": 20.0, "effectiveGrip": 25.0, "boltStiffness": 530.08, "memberStiffness": 784.62,
            "jointConstant": 0.4032},
  "preload": {"force": 36.0984, "stress": 622.5, "percentOfProof": 75.0, "torque": 72.2, "torqueCoefficient": 0.2},
  "loads": {"tensionPerBolt": 10.0, "minTensionPerBolt": 0.0},
  "results": {"boltLoad": 40.1304, "boltStress": 692.03, "clampRemaining": 30.1304, "separationLoad": 60.4862,
              "separated": false, "proofSafety": 1.199, "loadFactor": 2.984, "separationSafety": 6.049},
  "fatigue": {"alternatingStress": 34.76, "meanStress": 657.26, "enduranceStrength": 162, "safety": 1.619},
  "imageUrl": "https://api.apify.com/v2/key-value-stores/.../records/002-....png"
}
```

With a shear load, `shear` has the slip resistance and safety and the bolt shear stresses; a design adds `targets` and `alternatives`. 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 thread, grade, parts, tapped hole, count, loads and tightening; numbers carry their units, and inch threads or lbf switch the results to inch units.
2. **Bolt**: tensile stress area At = π/4·(d − 0.9382p)² (metric) or π/4·(d − 0.9743/n)² (inch); strengths for the grade and size; standard bolt length and thread length (2d + 6 mm, or 2d + 1/4 in); stiffness from the shank and threaded parts in the grip.
3. **Members**: two 30° cones from washer faces 1.5·d wide meet at the middle of the grip (for a cap screw, the grip reaches d/2 into the tapped part); each cone is cut where the material changes and the slices add in series (Shigley eq. 8-20).
4. **Loads**: Fb = Fi + C·P on the bolt and Fi − (1 − C)·P on the parts; load factor (Sp·At − Fi)/(C·P); separation factor Fi/((1 − C)·P); Goodman fatigue along the load line from the preload; slip resistance μ·(clamp left)·(shear planes).
5. **Design**: standard coarse sizes from M3 (or #10) upward, in each grade, until one meets the load factor, separation, fatigue and slip targets.

Results are engineering estimates for the stated assumptions. Torque control scatters the real preload by ±25% or more; for critical joints, control the preload more closely and confirm with the full VDI 2230 method or a test.

### Pricing

You pay one low price per joint, 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 joint takes a few milliseconds and a design search well under a second, plus the chart. A run through the API answers in about 5 to 10 seconds, including the cloud container starting.

### Tips and limits

- **Axial and shear loads** on each bolt are entered directly; for a bolt pattern under a moment or an eccentric load, share the load out over the bolts first (or give the worst bolt's share with `per bolt`).
- **Prying** of thin flanges isn't modeled; neither are thermal loads, embedding losses or preload relaxation in gaskets over time.
- **Fatigue** uses Shigley's endurance strengths for rolled threads, available for ISO 8.8 to 12.9, SAE 5, 7 and 8, A325 and A490. Other grades get the static checks and a note.
- **Thread stripping** is covered by the engagement rule (about 1·d in steel, 1.5·d in cast iron, 2·d in aluminum), not by a stripping calculation.
- **Limits**: 500 joints 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 `joints` as plain text and read `summary`, `preload.torque`, `results.loadFactor`, `results.separationSafety`, `fatigue.safety`, `bolt.length` and `warnings`. A direct API call that waits for the answer:

```bash
curl -X POST "https://api.apify.com/v2/acts/jumblemog~bolted-joint-calculator/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"joints": ["4 x M8 8.8 cap screws into aluminum, 10 mm steel bracket, 12 kN total, washers"]}'
```

`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/bolted-joint-calculator").call(run_input={
    "joints": [{"size": "M16", "grade": "8.8", "count": 8, "load": "120 kN", "finish": "lubricated",
                "members": [{"thickness": "20 mm", "material": "steel"},
                            {"thickness": "3 mm", "E": "0.5 GPa", "material": "gasket"},
                            {"thickness": "20 mm", "material": "steel"}]}],
})
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 8 (bolt and member stiffness, joint constant, preload and torque, load and separation factors, fatigue and endurance strengths, slip).
- Data: thread dimensions from ISO 261/724 and ASME B1.1; strengths from ISO 898-1, ISO 3506-1, SAE J429 and ASTM F3125; torque with friction from VDI 2230 Part 1.

# Actor input Schema

## `joints` (type: `array`):

One joint per entry, as a line of text or an object. Give the bolt ('M12', 'M10x1.25', '1/2-13 UNC', '3/8 UNF', '#10-24') and grade ('8.8', '10.9', 'grade 5', 'A325', 'A2-70'), the clamped parts ('2 x 15 mm steel', '20 mm aluminum + 10 mm steel'), 'cap screws into cast iron' for a tapped hole, the bolt count and the loads ('10 kN per bolt', '60 kN total tension', '0 to 60 kN cyclic', '8 kN shear'). Optional: 'washers', 'lubricated' or 'zinc' (torque coefficient), 'friction 0.12' (VDI 2230 torque), 'preload 70%', 'torque 50 N·m', 'permanent' (90% preload), 'slip factor 0.3', 'safety 2'. Write 'design' (or leave out the size) to find the smallest bolt that works. Object fields: mode, size, grade, count, members (thickness with material or E), grip, tapped, tappedMaterial, load, minLoad, shear, perBolt, cyclic, preload, preloadPercent, torque, permanent, finish, friction, nutFactor, slipFriction, shearPlanes, safety, washer, length, units, title.

## `grade` (type: `string`):

For joints that don't name one, such as '8.8' or 'grade 5'. Otherwise 8.8 (metric) or SAE grade 5 (inch); design tries 8.8, 10.9 and 12.9 (or grades 5 and 8).

## `finish` (type: `string`):

Sets the torque coefficient K in T = K·F·d (Shigley Table 8-15).

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

For numbers written without a unit. Inch threads and lbf switch to inch units on their own.

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

The joint diagram and the safety factors for each joint.

## Actor input object example

```json
{
  "joints": [
    "M12 8.8 bolt, 2 x 15 mm steel, 10 kN per bolt",
    "6 x M10 10.9 cap screws into cast iron, 20 mm aluminum flange, 0 to 60 kN total tension, cyclic",
    "1/2-13 UNC grade 5, 1.5 in steel + 0.5 in aluminum, 2000 lbf per bolt, lubricated",
    "design bolts: 4 bolts, 40 kN tension, 8 kN shear, 2 x 12 mm steel plates, safety 2",
    {
      "title": "Pump flange",
      "size": "M16",
      "grade": "8.8",
      "count": 8,
      "members": [
        {
          "thickness": "20 mm",
          "material": "steel"
        },
        {
          "thickness": "3 mm",
          "E": "0.5 GPa",
          "material": "gasket"
        },
        {
          "thickness": "20 mm",
          "material": "steel"
        }
      ],
      "load": "120 kN",
      "finish": "lubricated"
    }
  ],
  "units": "mm",
  "charts": true
}
```

# Actor output Schema

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

One row per joint: 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 = {
    "joints": [
        "M12 8.8 bolt, 2 x 15 mm steel, 10 kN per bolt",
        "6 x M10 10.9 cap screws into cast iron, 20 mm aluminum flange, 0 to 60 kN total tension, cyclic",
        "1/2-13 UNC grade 5, 1.5 in steel + 0.5 in aluminum, 2000 lbf per bolt, lubricated",
        "design bolts: 4 bolts, 40 kN tension, 8 kN shear, 2 x 12 mm steel plates, safety 2",
        {
            "title": "Pump flange",
            "size": "M16",
            "grade": "8.8",
            "count": 8,
            "members": [
                {
                    "thickness": "20 mm",
                    "material": "steel"
                },
                {
                    "thickness": "3 mm",
                    "E": "0.5 GPa",
                    "material": "gasket"
                },
                {
                    "thickness": "20 mm",
                    "material": "steel"
                }
            ],
            "load": "120 kN",
            "finish": "lubricated"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("jumblemog/bolted-joint-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 = { "joints": [
        "M12 8.8 bolt, 2 x 15 mm steel, 10 kN per bolt",
        "6 x M10 10.9 cap screws into cast iron, 20 mm aluminum flange, 0 to 60 kN total tension, cyclic",
        "1/2-13 UNC grade 5, 1.5 in steel + 0.5 in aluminum, 2000 lbf per bolt, lubricated",
        "design bolts: 4 bolts, 40 kN tension, 8 kN shear, 2 x 12 mm steel plates, safety 2",
        {
            "title": "Pump flange",
            "size": "M16",
            "grade": "8.8",
            "count": 8,
            "members": [
                {
                    "thickness": "20 mm",
                    "material": "steel",
                },
                {
                    "thickness": "3 mm",
                    "E": "0.5 GPa",
                    "material": "gasket",
                },
                {
                    "thickness": "20 mm",
                    "material": "steel",
                },
            ],
            "load": "120 kN",
            "finish": "lubricated",
        },
    ] }

# Run the Actor and wait for it to finish
run = client.actor("jumblemog/bolted-joint-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 '{
  "joints": [
    "M12 8.8 bolt, 2 x 15 mm steel, 10 kN per bolt",
    "6 x M10 10.9 cap screws into cast iron, 20 mm aluminum flange, 0 to 60 kN total tension, cyclic",
    "1/2-13 UNC grade 5, 1.5 in steel + 0.5 in aluminum, 2000 lbf per bolt, lubricated",
    "design bolts: 4 bolts, 40 kN tension, 8 kN shear, 2 x 12 mm steel plates, safety 2",
    {
      "title": "Pump flange",
      "size": "M16",
      "grade": "8.8",
      "count": 8,
      "members": [
        {
          "thickness": "20 mm",
          "material": "steel"
        },
        {
          "thickness": "3 mm",
          "E": "0.5 GPa",
          "material": "gasket"
        },
        {
          "thickness": "20 mm",
          "material": "steel"
        }
      ],
      "load": "120 kN",
      "finish": "lubricated"
    }
  ]
}' |
apify call jumblemog/bolted-joint-calculator --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,jumblemog/bolted-joint-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/lHEakzpCoTBURGLS4/builds/qnWpWAsPH0LQaWEwp/openapi.json