ForHosting KIT · Engineering & construction

Band brake torque calculator

A tight-side tension of 1200 N and a slack side of 400 N on a drum of radius 0.25 m give a braking torque of 200 N·m. Use it to size shafts and actuators from known band forces. Free in your browser.

Free
Runs in your browser
No sign-up
Your data stays on your device

Run — free How it works & API

Use it from WebAPIEmailTelegramApp soon

Worked example

If you enter

Tight tension: 1,200
Slack tension: 400
Drum radius: 0.25

You get

Tension difference: 800 N·m
Braking torque: 200

Band brakes wrap a flexible friction band around a rotating drum so that a small actuating force can produce large braking torque through the difference between tight-side and slack-side tensions. Machine design students, plant engineers, and winch or hoist designers need that torque quickly from measured or specified band forces and drum size, without rebuilding a full friction model every time. This band brake torque calculator accepts tight tension T1, slack tension T2, and drum radius r, then returns the classical braking torque Tb equals (T1 minus T2) times r in coherent units such as newton-metres when force is in newtons and radius in metres.

What band brake torque means and why Tb = (T1 − T2) · r

A simple band brake presses a flexible belt or strap against a cylindrical drum. Friction along the wrap makes the tension higher on the tight side (T1) than on the slack side (T2). The net tangential force the band applies to the drum is the difference T1 minus T2; multiplying that force by the drum radius r converts it into a moment about the drum axis—the braking torque Tb.

Textbooks write this identity as Tb equals (T1 minus T2) times r, and it holds for both external and internal band arrangements when r is the effective contact radius and the tensions are the true band end forces. The same product appears whether the drum is used as a hoist brake, a winch stop, or a machine-tool clutch brake: torque capacity is set by how large a tension difference the wrap can sustain and by how large the drum is.

Designers often relate T1 over T2 to the belt friction formula involving the coefficient of friction μ and the wrap angle θ, but once those tensions are known—from measurement, from a prior μθ analysis, or from a vendor table—this calculator does not re-derive the ratio. It only multiplies the given difference by radius so you get a reproducible torque for sizing shafts, selecting actuators, and checking energy absorption rates. Zero difference correctly yields zero torque; equal tensions mean the band is not producing a net drag couple.

Negative radius or inverted tension labels are rejected rather than silently returning a signed oddity, matching classroom language that the tight side must not be smaller than the slack side when reporting braking capacity.

Who sizes band brakes with this torque

Mechanical design courses and machine-element exams routinely ask for band brake torque from given end tensions and drum diameter; a deterministic oracle marks wrong inverted T1/T2 pairs and never invents friction coefficients the problem did not supply. Hoist, crane, and winch engineers convert measured band-end loads into shaft torque when verifying brake capacity after liner wear or spring adjustment. Plant maintenance scripts can log torque from load-cell readings on the tight and slack sides without embedding ad-hoc spreadsheets that disagree on rounding.

Content sites that rank for band brake torque calculator, braking torque from tight and slack tension, or drum band brake formula benefit from a live free tool whose arithmetic matches the paid automation path byte-for-byte. Invalid input is not billed.

What you can do with it

Hoist and winch brake checks

Convert measured or specified band-end forces and drum size into braking torque when verifying capacity after adjustment or liner wear.

FAQ

What units should I use?

Any coherent force and length pair: newtons and metres give N·m; keep T1, T2, and r consistent. The response labels unit as N·m for the SI convention.

Why must tight tension be at least slack tension?

By definition the tight side carries the larger band force during braking.

Does this use the belt friction formula e^(μθ)?

No. This calculator takes the given end tensions and radius only.

How do I calculate band brake torque from the two tensions?

Subtract the slack-side tension from the tight-side tension and multiply by the drum radius. With 1200 and 400 on a radius of 0.25, the difference is 800 and the braking torque is 200 newton-metres.

Does the result include heat fade or stopping distance?

No. It is the static braking torque only. Combine it with your own drum speed if you need power dissipation; thermal fade and dynamic stopping distance are outside this calculation.

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

POSThttps://api.kit.forhosting.com/eng/band-brake-torque

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/band-brake-torque \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d '{"tight_tension":1200,"slack_tension":400,"drum_radius":0.25}'

const res = await fetch("https://api.kit.forhosting.com/eng/band-brake-torque", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.KIT_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "tight_tension": 1200,
    "slack_tension": 400,
    "drum_radius": 0.25
  })
});
const { task_id } = await res.json();

import os, requests

res = requests.post(
    "https://api.kit.forhosting.com/eng/band-brake-torque",
    headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
    json={
    "tight_tension": 1200,
    "slack_tension": 400,
    "drum_radius": 0.25
},
)
task_id = res.json()["task_id"]

<?php
$res = file_get_contents("https://api.kit.forhosting.com/eng/band-brake-torque", false, stream_context_create([
  "http" => [
    "method"  => "POST",
    "header"  => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
    "content" => '{"tight_tension":1200,"slack_tension":400,"drum_radius":0.25}',
  ],
]));
$task = json_decode($res, true);

body := bytes.NewBufferString(`{"tight_tension":1200,"slack_tension":400,"drum_radius":0.25}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/eng/band-brake-torque", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)

Example request

{
  "tight_tension": 1200,
  "slack_tension": 400,
  "drum_radius": 0.25
}

Example response

{
  "task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
  "type": "eng.band_brake_torque",
  "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

Per request$0.002

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

Invalid input—missing fields, negative tensions, non-positive radius, or tight side smaller than slack—fails with invalid_input and is not billed.

Input contract, units, response shape, and error behaviour

Numeric results are rounded to twelve decimal places for stable goldens and automation. Example: tight tension twelve hundred, slack four hundred, radius zero point two five yields tension difference eight hundred and braking torque two hundred in coherent units—because (1200 − 400) × 0.25 equals 200. Pair the torque with your own drum speed if you need power dissipation; this capability solves static braking torque only and does not integrate thermal fade or dynamic stopping distance. POST a JSON body with three required finite numbers: tight_tension (aliases T1, t1, tight, tension_tight), the non-negative tight-side band force; slack_tension (aliases T2, t2, slack, tension_slack), the non-negative slack-side band force not greater than the tight side; and drum_radius (aliases r, radius, R, drum_r), a strictly positive drum radius in a length unit coherent with the force unit. When tensions are in newtons and radius in metres, braking_torque is in newton-metres (N·m); the same arithmetic works for lbf and feet if you stay consistent. Fields may arrive as JSON numbers or numeric strings. Missing fields, non-finite values, negative tensions, non-positive drum radius, or tight_tension less than slack_tension fail with invalid_input naming the problem; those failures are not billed. On success the body echoes rounded tight_tension, slack_tension, and drum_radius; reports tension_difference as T1 minus T2; returns braking_torque as that difference times radius; sets unit to N·m as the SI default label; and includes formula Tb = (T1 − T2) · r, method band_brake_torque, and a short human-readable message.

Where a band brake torque API earns its keep

Laboratory benches that instrument band brakes for friction labs can pin braking_torque in continuous integration against the same pure module students use in the browser. Keep requests small, pin the rounded braking_torque field in tests, and you get reproducible band brake moments for LMS plugins, edge workers, and design notebooks without standing up a full multibody contact model.

Integration use cases

Machine design homework and exams

Compute Tb=(T1−T2)·r from textbook tight/slack tensions and drum radius; reject inverted T1/T2 so graders get a clear invalid_input signal.

Lab and automation scripts

Pin braking_torque from load-cell T1/T2 and known radius in CI using the same pure module as the free browser widget.

Technical questions

How do I calculate band brake braking torque?

Send non-negative tight_tension T1, slack_tension T2 with T1≥T2, and positive drum_radius r. The API returns Tb=(T1−T2)·r as braking_torque in coherent units (N·m when SI).

What does the band brake torque calculator cost?

The browser tool is free. API requests use prepaid KIT balance at $0.002 per successful call; invalid input is not billed.

Read the full KIT documentation →

Run — free