Overhead conductor tension calculator
A 100 m span carrying 1 N per metre with 2 m of midspan sag needs 625 N of horizontal tension under the parabolic rule for level spans. Compare it with the conductor's rated breaking strength. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Span length
- 100
- Weight per unit length
- 1
- Sag
- 2
- Horizontal tension
- 625
- Approximation
- parabolic_sag
Overhead distribution and transmission lines hang between supports under self-weight, wind, and ice, so designers must set conductor tension high enough to keep midspan sag within clearance limits yet low enough to respect hardware, structure, and conductor strength. The classical parabolic approximation for a lightly sagged span states that horizontal tension equals the product of weight per unit length and span squared, divided by eight times the midspan sag.
What horizontal conductor tension means and when H = wL²/(8d) applies
A freely hanging conductor between two level supports forms a catenary, but when sag is small compared with the span—typically a few percent of L—the curve is well approximated by a parabola and the horizontal component of tension is nearly constant along the span. Under that approximation the geometric relation between midspan sag d, span length L, and uniform weight (force) per unit length w rearranges to the design formula H equals w times L squared over eight times d.
Here H is the horizontal tension the supports must resist and the value used in many stringing and clearance worksheets; w is the conductor mass density converted to force per unit length, or an equivalent load that already folds in ice and wind when you work with design loading; L is the horizontal distance between attachment points; and d is the allowable or observed midspan sag in the same length units as L.
Search intent for this landing clusters around overhead conductor tension calculator, horizontal tension from sag and span, power line conductor H equals w L squared over 8d, and transmission span sag tension formula. People want a numeric horizontal tension they can compare to rated breaking strength, to stringing charts, or to a spreadsheet model—not only a reminder that a textbook formula exists.
Keep units coherent: if w is in newtons per metre, L and d in metres, then H is in newtons; any other consistent force-and-length system works the same way because the engine does not convert units for you.
What you can do with it
Preliminary overhead-line clearance checks
Engineers and utility planners estimate horizontal tension for a proposed midspan sag before opening a full catenary or PLS-CADD model.
FAQ
What formula does this overhead conductor tension calculator use?
Under the parabolic sag approximation for a level span, horizontal tension is H = w L² / (8 d).
What happens if sag is zero or negative?
Sag must be a strictly positive finite number; zero sag would divide by zero in H=wL²/(8d) and is not charged.
Is this a full catenary solver?
No. This capability uses only the parabolic approximation for horizontal tension on a level span. Unequal supports, hyperbolic catenary, temperature, and creep are out of scope.
Is the overhead conductor tension calculator free?
The browser tool runs free on your device.
What units should I use for span, weight, and sag?
Any coherent set works if you keep them consistent. With w in N/m and L and d in metres, H is in newtons. The engine does not convert units for you.
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
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/cable-tension \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"span_length":100,"weight_per_unit_length":1,"sag":2}'const res = await fetch("https://api.kit.forhosting.com/eng/cable-tension", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"span_length": 100,
"weight_per_unit_length": 1,
"sag": 2
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/eng/cable-tension",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"span_length": 100,
"weight_per_unit_length": 1,
"sag": 2
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/eng/cable-tension", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"span_length":100,"weight_per_unit_length":1,"sag":2}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"span_length":100,"weight_per_unit_length":1,"sag":2}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/eng/cable-tension", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"span_length": 100,
"weight_per_unit_length": 1,
"sag": 2
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "eng.cable_tension",
"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
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
This overhead conductor tension calculator accepts those three finite positive numbers—span length, weight per unit length, and allowable sag—validates them, and returns horizontal tension together with echoed inputs and fixed formula labels as structured JSON.
What horizontal conductor tension means and when H = wL²/(8d) applies
Returning horizontal_tension, span_length, weight_per_unit_length, sag, formula, approximation, and method as JSON makes the result easy to paste into notes, pin in automated tests, or reuse across programming languages without reimplementing the arithmetic.
How this calculator validates input and applies the parabolic closed form
Span length, weight per unit length, and sag must all be strictly positive so the geometry and loading remain physically meaningful for this product contract—zero or negative sag would divide by zero or reverse the sag direction, and a zero span is not a supported line section. There is no full catenary hyperbolic solver, no unequal-support elevation difference mode, no temperature-change or creep iteration, no built-in conductor catalog table, and no unit conversion table; this capability is the level-span parabolic horizontal-tension case only. Send a JSON body with the three required fields span_length, weight_per_unit_length, and sag. Every field must be a finite number or a numeric string that parses to one; missing fields, empty strings, non-numeric text, NaN, and Infinity all fail immediately with invalid_input before any tension is returned, and failed validation is not charged against prepaid balance. Optional aliases such as L, span, length, w, weight, unit_weight, d, allowable_sag, and dip are accepted when documented so forms and scripts can use textbook symbols without renaming fields. After validation the engine computes horizontal tension as weight_per_unit_length times span_length squared divided by eight times sag, then rounds to a stable precision so the same input always yields the same JSON across JavaScript engines and Worker isolates. The same pure function powers the free in-browser tool and the API path, with no network call, no random seed, and no wall-clock timestamp in the computation path, which keeps goldens and continuous-integration checks reliable.
Practical use, limits, pricing, and delivery channels for span tension checks
Use the browser tool when you want an immediate horizontal tension check while grading power-system homework, comparing a hand calculation of w L squared over eight d, verifying that a proposed sag keeps H below a fraction of rated strength, or teaching how tension rises when span grows or when allowable sag shrinks. There is no language model, no external line-design service, and no randomness, so the capacity is safe to pin in continuous-integration checks and reproducible course materials. When your problem moves to full catenary geometry, unequal supports, or multi-span ruling spans with temperature and creep, switch to a more general line-design tool; this calculator stays focused on the single level-span parabolic horizontal tension so the answer stays transparent and fast. Each successful request is one billable item at $0.002; failed validation does not consume balance. Choose units consistently and stay within the published magnitude bounds so intermediate products remain finite on a Worker isolate. Results are fully deterministic: identical inputs always produce the same horizontal_tension value and the same formula, approximation, and method labels. Wire the endpoint into transmission drills, early-stage clearance worksheets, catalog conductor screeners, or preprocessing steps where you prefer explicit domain errors—such as rejecting zero sag or a zero span—over opaque widgets that cannot explain why a bad input was refused.
Integration use cases
Homework and exam verification
Students and graders compute horizontal conductor tension H = wL²/(8d) for given span, unit weight, and sag, and receive a clear invalid_input error when any input is non-positive.
Deterministic fixtures for cable-engineering tests
Pipelines that seed unit tests or interactive span demos call a pure H=wL²/(8d) oracle instead of reimplementing the formula in every language runtime.