# Bearing Life Calculator (ISO 281 L10, aISO, Rating Sizing) (`jumblemog/bearing-life-calculator`) Actor

Rolling bearing life calculator from plain text: equivalent load with X, Y, e, L10 and modified life with a1 and aISO (oil viscosity, contamination), static safety, duty cycles, and the dynamic rating a target life needs.

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

## Bearing Life Calculator (ISO 281 L10, aISO, Rating Sizing)

**How long will the bearing last? Describe it in one line and find out.** Type `6205, C 14.8 kN, C0 7.8 kN, Fr 2 kN, Fa 0.5 kN, 3000 rpm, ISO VG 68 at 70 C, 99% reliability, 20000 hours` or `find the rating: 2 kN radial at 1725 rpm, 5000 hours`. You get back:

- **The equivalent load** P = X·Fr + Y·Fa with the X, Y and e factors used (from Fa/C0 for deep-groove bearings), and the static equivalent load P0.
- **The basic rating life L10** in millions of revolutions and in hours.
- **The modified life Lnm** at your reliability (a1) and, when you give the oil and cleanliness, ISO 281's aISO from the viscosity ratio κ, the contamination factor ec and the fatigue load limit Cu.
- **The static safety** s0 = C0/P0.
- **The rating a target life needs**, by ISO 281 and by Shigley's three-parameter Weibull method, with the Weibull reliability your bearing reaches at the target.
- **Duty cycles**: several loads and speeds with their share of the time, combined into one equivalent load and mean speed.
- **A chart**: life against load on log scales with the operating point and the target, next to the lives (or the ratings needed).

Bearings: deep-groove ball, angular contact ball (15° to 45°), cylindrical roller, tapered roller, spherical roller, needle roller, self-aligning ball and thrust ball. Standard designations (6205-2RS, 7308 BE, NU 210, 30206, 22212, 51105) give the type, bore and outside diameter; sealed bearings count as clean. Metric (kN, mm) or inch (lbf, in): results come back in the units you wrote.

It's made for:

- Mechanical designers picking bearings for shafts, pulleys, gearboxes and motors.
- Maintenance and reliability engineers estimating remaining life and comparing lubricants.
- Engineering students working Shigley-style bearing problems.
- AI agents that need real bearing-life numbers instead of a guess.

![A 6205 deep-groove ball bearing analyzed by this Actor: L10 and L1m life against equivalent load on log scales with the operating point at 1.5 kN and the 20,000 hour target, next to bars of the L10 life of 5,295 hours, the L1m life of 4,792 hours and the target](https://api.apify.com/v2/key-value-stores/Km5b4PG3kYHdZSb1E/records/bearing-life-calculator-example.png?signature=aiiBHXSsQ5xMFnaQuiU0)

### How to use it

1. Write **Bearings**, one per entry. The form has examples.
2. Optionally set a default **reliability**, **target life**, **application factor**, **cleanliness** or the **Units**.
3. Click **Start**. Each bearing is a row in the results, with its summary, chart and report.

#### Writing a bearing

| You write | It means |
|---|---|
| `6205-2RS`, `7308 BE`, `NU 210`, `30206`, `22212`, `51105` | the bearing: type, bore and outside diameter |
| `deep groove`, `angular contact 25°`, `cylindrical roller`, `tapered roller`, `spherical roller`, `thrust ball` | the type, without a designation |
| `C 14.8 kN, C0 7.8 kN`, `Cu 0.335 kN` | the catalog ratings |
| `Fr 2 kN`, `Fa 0.5 kN`, `3 kN radial`, `700 lbf thrust` | the loads |
| `3000 rpm` | the speed |
| `20000 hours`, `500 million revolutions` | the target life |
| `99% reliability` | the reliability (90% if not given) |
| `application factor 1.2` | multiplies the loads |
| `ISO VG 68 at 70 C`, `viscosity 20 cSt` | the lubricant at operating temperature |
| `normal cleanliness`, `typical contamination`, `ec 0.5` | the cleanliness |
| `e 0.37, Y 1.6`, `Y1 2.4` | catalog factors for tapered and spherical roller bearings |
| `Fr 5 kN at 1500 rpm 60%; Fr 9 kN at 800 rpm 40%` | a duty cycle |
| `find the rating ...` (or no C) | the rating the target needs |

Objects work too; see Input.

### Examples

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

| Bearing | Result |
|---|---|
| `6205, C 14.8 kN, C0 7.8 kN, Fr 2 kN, Fa 0.5 kN, 3000 rpm, ISO VG 68 at 70 C, normal cleanliness, 99% reliability, 20000 hours` | Fa/Fr under e, so P = 2 kN; L10 2,251 h; κ 1.5, aISO 2.47, L1m 1,380 h; a 36.1 kN rating would be needed, with a warning |
| `deep groove ball bearing, radial load 413 lbf, application factor 1.2, 300 rpm, 30000 hours, 99% reliability` (Shigley Example 11-3) | Rating needed 6,690 lbf by the Weibull method (book: 6,696 with its approximate form) and 6,421 lbf by ISO 281 |
| `30206 tapered roller, C 54 kN, C0 63 kN, e 0.37, Y 1.6, Fr 8 kN, Fa 4 kN, 800 rpm, 15000 h` | P = 0.4·8 + 1.6·4 = 9.6 kN; L10 6,594 h, short of the target; 69.1 kN needed |
| `6308, C 42.3 kN, C0 24 kN: Fr 5 kN at 1500 rpm 60%; Fr 9 kN, Fa 2 kN at 800 rpm 40%; 99% reliability, VG 46 at 60 C` | Duty-cycle P 6.57 kN at a mean 1,220 rpm; L10 3,648 h, L1m 1,851 h |
| `7308 BE, C 50 kN, C0 33.5 kN, Fr 6 kN, Fa 9 kN, 1500 rpm` | 40° angular contact: P = 0.35·6 + 0.57·9 = 7.23 kN; L10 3,675 h |

The tests check that:

- Shigley's Examples 11-1 and 11-3 come out, and the Weibull rating gives back its reliability.
- a1, ν1, the oil viscosity at temperature and aISO follow ISO 281 (with the cap of 50).
- X, Y and e follow the ISO tables for deep-groove, angular contact and tapered roller bearings.
- Designations give the right type and size, and duty cycles average with the cube (ball) or 10/3 power (roller).

### How-to examples

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

#### How to calculate bearing life (ISO 281 L10 and modified life)

```json
{"bearings": ["6205, C 14.8 kN, C0 7.8 kN, Fr 2 kN, Fa 0.5 kN, 3000 rpm, ISO VG 68 at 70 C, normal cleanliness, 99% reliability, 20000 hours"]}
```

Result: Fa/Fr is under e, so P = 2 kN; L10 2,251 h; κ 1.5, aISO 2.47 and L1m 1,380 h. A 36.1 kN rating would be needed, with a warning.

#### How to find the dynamic load rating a bearing needs

```json
{"bearings": ["deep groove ball bearing, radial load 413 lbf, application factor 1.2, 300 rpm, 30000 hours, 99% reliability"]}
```

Result: this is Shigley's Example 11-3: 6,690 lbf by the Weibull method (book 6,696 with its approximate form) and 6,421 lbf by ISO 281.

#### How to calculate bearing life over a duty cycle

```json
{"bearings": ["6308, C 42.3 kN, C0 24 kN: Fr 5 kN at 1500 rpm 60%; Fr 9 kN, Fa 2 kN at 800 rpm 40%; 99% reliability, VG 46 at 60 C"]}
```

Result: duty-cycle P 6.57 kN at a mean 1,220 rpm; L10 3,648 h and L1m 1,851 h.

#### How to let an AI agent check bearing life

Add this Actor to the [Apify MCP server](https://mcp.apify.com) with `https://mcp.apify.com/?tools=jumblemog/bearing-life-calculator`. The agent passes the bearing, loads and speed in one line and answers with the life in hours or the rating needed.

### FAQ

**Which bearing types does it know?** Deep-groove and angular contact ball bearings, and tapered and spherical roller bearings, with ISO 281's X, Y and e for each.

**Does it look up C from the bearing number?** No. Ratings differ between makers, so give C and C0 from the catalog; the designation sets the type and size.

**What does the lubricant change?** The ISO 281 aISO factor, from the oil viscosity at temperature and the cleanliness. Without a lubricant aISO is 1.

**What isn't covered?** Grease life, speed limits, temperature rise, fits and clearance, oscillating motion, and the thrust a tapered or angular contact bearing induces in its partner.

### Input

| Field | What it is |
|---|---|
| `bearings` | Bearings, as text or objects. |
| `reliability` | Default reliability in % (90). |
| `lifeHours` | Default target life in hours. |
| `applicationFactor` | Default application factor (1). |
| `contamination` | Default cleanliness (normal cleanliness). |
| `units` | `mm` (kN and mm, default) or `in` (lbf and inches), for numbers written without a unit. |
| `charts` | Draw charts (default on). |

**A bearing as an object** takes:

- `designation` or `type`, `contactAngle`, `bore`, `outsideDiameter`.
- `c`, `c0`, `cu`; `e`, `y`, `y1`, `y0` for roller bearings.
- `fr`, `fa`, `rpm`, or `loads`: a list of `{fr, fa, rpm, share}`.
- `reliability`, `lifeHours` or `lifeRevolutions`, `applicationFactor`.
- `viscosity` (mm²/s), or `oilGrade` (ISO VG) with `temperature` (°C); `contamination` (a class or ec).
- `mode` (`analyze` or `design`), `units`, `title`, and `text` (a line of text, with the other fields overriding what it says).

### Output

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

```json
{
  "request": 1, "status": "ok", "type": "bearing", "mode": "analyze", "title": "6205 deep-groove ball bearing",
  "units": {"force": "kN", "length": "mm", "speed": "rpm", "viscosity": "mm²/s"},
  "bearing": {"designation": "6205", "type": "Deep-groove ball bearing", "bore": 25, "outsideDiameter": 52,
              "c": 14.8, "c0": 7.8, "cu": 0.2889, "cuEstimated": true, "lifeExponent": 3},
  "loads": [{"fr": 2.0, "fa": 0.5, "rpm": 3000, "faOverC0": 0.0641, "e": 0.2658, "x": 1.0, "y": 0.0, "p": 2.0}],
  "equivalentLoad": 2.0, "meanSpeed": 3000, "staticSafety": 3.9,
  "life": {"reliability": 99, "l10Revolutions": 405.22, "l10Hours": 2251.2, "a1": 0.2483, "aIso": 2.469,
           "lnmHours": 1379.6},
  "lubrication": {"viscosity": 19.97, "ratedViscosity": 13.24, "kappa": 1.508, "ec": 0.55},
  "target": {"hours": 20000, "requiredC": 36.087, "requiredCWeibull": 50.807, "meets": false},
  "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 bearing, ratings, loads, speed, target and options; numbers carry their units.
2. **Equivalent load**: ISO 281's X, Y and e by type (deep-groove from Fa/C0, angular contact by contact angle, tapered and spherical from the catalog's e and Y); ISO 76 for P0. Duty cycles: P = (Σ U·n·P^p / Σ U·n)^(1/p) with p = 3 for ball and 10/3 for roller bearings.
3. **Life**: L10 = (C/P)^p million revolutions; Lnm = a1·aISO·L10 with a1 = 0.95·(ln(1/R)/ln(1/0.9))^(2/3) + 0.05.
4. **aISO**: ν1 from the speed and pitch diameter, κ = ν/ν1 (oil viscosity at temperature by the Walther equation), ec from the cleanliness class and size, Cu from the catalog or estimated from C0 (Annex B), then ISO 281 eqs. 15 to 18, capped at 50.
5. **Rating needed**: C = P·(L/(a1·aISO))^(1/p) by ISO 281, and C10 = af·F·\[xD/(x0 + (θ − x0)·ln(1/R)^(1/b))]^(1/a) by Shigley's Weibull method (x0 0.02, θ 4.459, b 1.483).

Results are engineering estimates for the stated assumptions; check the catalog's own life method, minimum load, speed limits and fits before buying.

### Pricing

You pay one low price per bearing, 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 bearing takes a millisecond, plus the chart. A run through the API answers in about 5 to 10 seconds, including the cloud container starting.

### Tips and limits

- **Use catalog ratings**: C, C0 and Cu differ between makers; the Actor doesn't guess C from a designation.
- **Tapered and angular contact pairs**: the thrust each bearing induces in its partner isn't added; give each bearing's net axial load.
- **Without a lubricant** aISO is 1, so the life is L10 corrected only for reliability.
- **Not covered**: grease life, speed limits, temperature rise, fits and clearance, oscillating motion.
- **Limits**: 500 bearings 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 `bearings` as plain text and read `summary`, `life`, `staticSafety`, `target` and `warnings`. A direct API call that waits for the answer:

```bash
curl -X POST "https://api.apify.com/v2/acts/jumblemog~bearing-life-calculator/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"bearings": ["6206-2RS, C 20.3 kN, C0 11.2 kN, Fr 3 kN, Fa 0.8 kN, 1450 rpm, 25000 hours"]}'
```

`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/bearing-life-calculator").call(run_input={
    "bearings": [{"designation": "22212", "c": "204 kN", "c0": "216 kN", "e": 0.28, "y1": 2.4, "y": 3.6,
                  "loads": [{"fr": "30 kN", "fa": "3 kN", "rpm": 120, "share": 70},
                            {"fr": "45 kN", "fa": "5 kN", "rpm": 120, "share": 30}],
                  "oilGrade": 220, "temperature": 60, "lifeHours": 60000}],
})
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: ISO 281:2007 and ISO 76 as presented in their published equations, and Budynas and Nisbett, *Shigley's Mechanical Engineering Design*, chapter 11.

# Actor input Schema

## `bearings` (type: `array`):

One bearing per entry, as a line of text or an object. Give the bearing ('6205', '7308 BE', 'NU 210', '30206', '22212', '51105', or a type such as 'deep groove', 'angular contact 25°', 'cylindrical roller', 'tapered roller', 'spherical roller', 'thrust ball'), its catalog ratings ('C 14.8 kN, C0 7.8 kN', optional 'Cu 0.335 kN'), the loads ('Fr 2 kN', 'Fa 0.5 kN', or '3 kN radial') and the speed ('3000 rpm'). Optional: the target life ('20000 hours', '500 million revolutions'), '99% reliability', 'application factor 1.2', the lubricant ('ISO VG 68 at 70 C' or 'viscosity 20 cSt') and cleanliness ('normal cleanliness', 'typical contamination', 'ec 0.5'), 'e 0.37, Y 1.6' for tapered and spherical roller bearings, and a duty cycle as cases separated by ';' ('Fr 5 kN at 1500 rpm 60%; Fr 9 kN at 800 rpm 40%'). Without C it finds the rating the target life needs. Object fields: mode, designation, type, c, c0, cu, bore, outsideDiameter, contactAngle, e, y, y1, y0, fr, fa, rpm, loads (list of fr, fa, rpm, share), reliability, lifeHours, lifeRevolutions, applicationFactor, viscosity, oilGrade, temperature, contamination, units, title.

## `reliability` (type: `string`):

90% (L10) if unset.

## `lifeHours` (type: `string`):

For bearings that don't give one, such as '20000'.

## `applicationFactor` (type: `string`):

Multiplies the loads (Shigley's af): 1 for smooth running, 1.2-1.5 for machinery with light shock, up to 3 for heavy impact. 1 if unset.

## `contamination` (type: `string`):

Sets the contamination factor ec for aISO when a lubricant is given. Normal cleanliness if unset.

## `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`):

Life against load on log scales, and the lives or ratings needed, for each bearing.

## Actor input object example

```json
{
  "bearings": [
    "6205, C 14.8 kN, C0 7.8 kN, Fr 2 kN, Fa 0.5 kN, 3000 rpm, ISO VG 68 at 70 C, normal cleanliness, 99% reliability, 20000 hours",
    "deep groove ball bearing, radial load 413 lbf, application factor 1.2, 300 rpm, 30000 hours, 99% reliability",
    "30206 tapered roller, C 54 kN, C0 63 kN, e 0.37, Y 1.6, Fr 8 kN, Fa 4 kN, 800 rpm, 15000 h",
    {
      "title": "Conveyor pulley bearing, duty cycle",
      "designation": "22212",
      "c": "204 kN",
      "c0": "216 kN",
      "e": 0.28,
      "y1": 2.4,
      "y": 3.6,
      "loads": [
        {
          "fr": "30 kN",
          "fa": "3 kN",
          "rpm": 120,
          "share": 70
        },
        {
          "fr": "45 kN",
          "fa": "5 kN",
          "rpm": 120,
          "share": 30
        }
      ],
      "oilGrade": 220,
      "temperature": 60,
      "contamination": "typical contamination",
      "lifeHours": 60000
    }
  ],
  "units": "mm",
  "charts": true
}
```

# Actor output Schema

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

One row per bearing: 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 = {
    "bearings": [
        "6205, C 14.8 kN, C0 7.8 kN, Fr 2 kN, Fa 0.5 kN, 3000 rpm, ISO VG 68 at 70 C, normal cleanliness, 99% reliability, 20000 hours",
        "deep groove ball bearing, radial load 413 lbf, application factor 1.2, 300 rpm, 30000 hours, 99% reliability",
        "30206 tapered roller, C 54 kN, C0 63 kN, e 0.37, Y 1.6, Fr 8 kN, Fa 4 kN, 800 rpm, 15000 h",
        {
            "title": "Conveyor pulley bearing, duty cycle",
            "designation": "22212",
            "c": "204 kN",
            "c0": "216 kN",
            "e": 0.28,
            "y1": 2.4,
            "y": 3.6,
            "loads": [
                {
                    "fr": "30 kN",
                    "fa": "3 kN",
                    "rpm": 120,
                    "share": 70
                },
                {
                    "fr": "45 kN",
                    "fa": "5 kN",
                    "rpm": 120,
                    "share": 30
                }
            ],
            "oilGrade": 220,
            "temperature": 60,
            "contamination": "typical contamination",
            "lifeHours": 60000
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("jumblemog/bearing-life-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 = { "bearings": [
        "6205, C 14.8 kN, C0 7.8 kN, Fr 2 kN, Fa 0.5 kN, 3000 rpm, ISO VG 68 at 70 C, normal cleanliness, 99% reliability, 20000 hours",
        "deep groove ball bearing, radial load 413 lbf, application factor 1.2, 300 rpm, 30000 hours, 99% reliability",
        "30206 tapered roller, C 54 kN, C0 63 kN, e 0.37, Y 1.6, Fr 8 kN, Fa 4 kN, 800 rpm, 15000 h",
        {
            "title": "Conveyor pulley bearing, duty cycle",
            "designation": "22212",
            "c": "204 kN",
            "c0": "216 kN",
            "e": 0.28,
            "y1": 2.4,
            "y": 3.6,
            "loads": [
                {
                    "fr": "30 kN",
                    "fa": "3 kN",
                    "rpm": 120,
                    "share": 70,
                },
                {
                    "fr": "45 kN",
                    "fa": "5 kN",
                    "rpm": 120,
                    "share": 30,
                },
            ],
            "oilGrade": 220,
            "temperature": 60,
            "contamination": "typical contamination",
            "lifeHours": 60000,
        },
    ] }

# Run the Actor and wait for it to finish
run = client.actor("jumblemog/bearing-life-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 '{
  "bearings": [
    "6205, C 14.8 kN, C0 7.8 kN, Fr 2 kN, Fa 0.5 kN, 3000 rpm, ISO VG 68 at 70 C, normal cleanliness, 99% reliability, 20000 hours",
    "deep groove ball bearing, radial load 413 lbf, application factor 1.2, 300 rpm, 30000 hours, 99% reliability",
    "30206 tapered roller, C 54 kN, C0 63 kN, e 0.37, Y 1.6, Fr 8 kN, Fa 4 kN, 800 rpm, 15000 h",
    {
      "title": "Conveyor pulley bearing, duty cycle",
      "designation": "22212",
      "c": "204 kN",
      "c0": "216 kN",
      "e": 0.28,
      "y1": 2.4,
      "y": 3.6,
      "loads": [
        {
          "fr": "30 kN",
          "fa": "3 kN",
          "rpm": 120,
          "share": 70
        },
        {
          "fr": "45 kN",
          "fa": "5 kN",
          "rpm": 120,
          "share": 30
        }
      ],
      "oilGrade": 220,
      "temperature": 60,
      "contamination": "typical contamination",
      "lifeHours": 60000
    }
  ]
}' |
apify call jumblemog/bearing-life-calculator --silent --output-dataset

```

## MCP server setup

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