String frequency after tension change
Raise a string's tension from 100 to 144 and a 440 Hz note climbs to 528 Hz: pitch follows the square root of the tension ratio while length and gauge stay the same. Enter the old frequency and both tensions. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Initial frequency
- 440
- Initial tension
- 100
- New tension
- 144
- Tension ratio
- 1.44 Hz
- Frequency ratio
- 1.2
- New frequency
- 528
When you retune a guitar string, tighten a piano wire, or change hanging mass on a sonometer, the pitch shifts with the square root of the tension ratio while length and linear density stay fixed. Students, luthiers, and lab scripts need the new frequency without rebuilding the full f equals one over two L times square root of T over mu relation every time. This string frequency after tension change calculator accepts the initial frequency f one, the initial tension T one, and the new tension T two, evaluates f two equals f one times the square root of T two over T one, and returns the new frequency together with the tension ratio and frequency ratio.
Where tension-change frequency calculations fit in study, labs, and software
Students meet f two equals f one times the square root of T two over T one when a textbook moves from the full harmonic-string formula to guitar retuning, piano wire tensioning, and sonometer mass changes, when a lab asks how pitch shifts after hanging a different mass on a wire, or when a contest problem gives an old frequency and two tensions and demands the new hertz value without a calculator under the desk.
Teachers can pre-generate answer keys for modest inputs without trusting opaque apps that silently switch units or drop scientific notation. Luthiers and instrument designers estimate how much tension increase is needed to raise a string by a target interval when length and gauge are already fixed. Developers call the same contract from scripts to seed deterministic test vectors for string simulators, to normalize user-entered retune ratios before plotting spectra, or to satisfy programming-challenge statements that demand frequency after a tension change rather than a hand-waved sketch.
Product and education tools use the relation when a learner types hertz and two forces and the UI must show the new pitch with a clean formula reminder.
What you can do with it
Homework and lab retune checks
Convert textbook initial frequency and two tensions into the new frequency before sonometer labs or guitar pitch comparisons.
Instrument design and tutoring software
Normalize user-entered f₁, T₁, and T₂ into the retuned frequency for interactive lessons, answer keys, and design notebooks.
FAQ
What does the string frequency after tension change calculator cost?
It is free in your browser on this page.
How is the new frequency defined here?
For non-negative f₁, positive T₁, and non-negative T₂ (with L and μ fixed), f₂ = f₁ · √(T₂/T₁). With f₁ in hertz the result is labelled in Hz.
What happens if initial tension is zero or negative?
Initial tension must be positive so the ratio T₂/T₁ is defined and physical.
Does this tool need string length or linear density?
No. Those cancel when only tension changes. If you need absolute frequency from L, T, and μ, use a harmonic-string calculator instead.
Why are results rounded to twelve decimal places?
Twelve decimal places keep comparisons reproducible across runtimes.
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/optics/string-frequency-from-tension-change \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"initial_frequency":440,"initial_tension":100,"new_tension":144}'const res = await fetch("https://api.kit.forhosting.com/optics/string-frequency-from-tension-change", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"initial_frequency": 440,
"initial_tension": 100,
"new_tension": 144
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/optics/string-frequency-from-tension-change",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"initial_frequency": 440,
"initial_tension": 100,
"new_tension": 144
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/optics/string-frequency-from-tension-change", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"initial_frequency":440,"initial_tension":100,"new_tension":144}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"initial_frequency":440,"initial_tension":100,"new_tension":144}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/optics/string-frequency-from-tension-change", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"initial_frequency": 440,
"initial_tension": 100,
"new_tension": 144
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "optics.string_frequency_from_tension_change",
"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
Zero new tension correctly yields zero new frequency; non-positive initial tension and negative inputs fail with invalid_input instead of a silent NaN.
What frequency scaling with tension means and what the response contains
An ideal thin string fixed at both ends has fundamental frequency f one equal to one over two L times the square root of tension over linear density. If only the tension changes while vibrating length L and linear mass density mu stay constant, every factor except the square root of T cancels in a ratio, leaving the compact rule f two over f one equals the square root of T two over T one, or f two equals f one times the square root of the tension ratio. Physically, quadrupling tension doubles frequency; reducing tension to one quarter of its former value halves frequency; leaving tension unchanged leaves frequency unchanged. This calculator takes initial_frequency, initial_tension, and new_tension, validates them as finite numbers inside a documented magnitude ceiling, and returns the rounded inputs, tension_ratio as T two over T one, frequency_ratio as the square root of that quotient, new_frequency in the same unit as the input frequency (labelled Hz when you supply hertz), a formula string, a method tag string_frequency_from_tension_ratio, and the unit label. There is no approximate pitch detection from audio, no FFT of a plucked sample, and no random sampling of periods: the engine either builds an exact floating-point product or rejects the input with invalid_input. Rejected cases include missing fields, non-finite values, magnitudes above the ceiling, any initial frequency that is negative, non-positive initial tension, and negative new tension.
Input contract, response shape, and how results stay reproducible
Optional leading plus signs and scientific notation on numeric strings are allowed when they parse as finite decimals; embedded spaces, hex prefixes, and non-numeric tokens are rejected with a clear message so a bad cell does not become a wrong pitch. Initial tension must be strictly positive so the ratio T two over T one is defined; zero or negative initial tension is rejected. New tension may be zero, which yields zero new frequency and zero frequency ratio, matching a string that is no longer under tension. Example: four hundred forty hertz, one hundred newtons, and one hundred forty-four newtons yields tension ratio one point four four, frequency ratio one point two, and new frequency five hundred twenty-eight hertz. POST a JSON body with three required finite numbers: initial_frequency for the starting pitch in hertz or any consistent frequency unit, initial_tension for the starting axial force, and new_tension for the force after the change in the same force unit. Each field may arrive as a JSON number or as a numeric string; aliases f1, frequency, f_old, and f for initial frequency, t1, T1, tension, and T_old for initial tension, and t2, T2, and T_new for new tension are accepted so spreadsheets, query strings, and typed forms can reuse the same contract. Initial frequency must be non-negative: a negative frequency is not physical for this model and fails with invalid_input. On success the body echoes the cleaned inputs, tension_ratio, frequency_ratio, new_frequency, formula, unit, and method. Pair the free browser run on this page with the priced API when you need the identical mathematical result inside an automated pipeline without re-implementing the square root and multiply yourself.
Where tension-change frequency calculations fit in study, labs, and software
On this page the work runs entirely in your browser; through the API each successful lookup costs $0.002, failed validation is not charged, and nothing is stored after the response returns. That split — free interactive exploration and a priced, identical API — matches the rest of the KIT tier-A catalog and lets you move from a classroom demo to an automated pipeline without changing the mathematical result. Pair it with the harmonic-string endpoint when you need absolute frequency from L, T, and mu, and with wave-speed tools when you already know tension and linear density separately.
Integration use cases
Deterministic test fixtures
Generate reproducible f₂ values for unit tests, property checks, and CI assertions in string or audio simulators.