ForHosting KIT · Engineering & construction

Wheatstone bridge calculator

With ratio arms of 100 and 200 ohms and a known arm of 50 ohms, the unknown Rx is 100 ohms: enter the three known resistances of a balanced bridge and get the fourth, with the ratio and each step. 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

Ratio-arm resistance R1: 100
Ratio-arm resistance R2: 200
R3: 50

You get

Rx: 100
Unknown resistance: 100
Balance ratio: 2
Product r1 rx: 10,000

A Wheatstone bridge calculator turns three known arm resistances into the unknown fourth resistance of a balanced bridge. Bridge measurements remain the standard way to resolve an unknown resistor against a known ratio without a precision ammeter, and students still need the same closed form for null-deflection problems.

How a balanced bridge reveals a resistance

A Wheatstone bridge arranges four resistors in a loop: two ratio arms, a known arm and the unknown one you want to measure, with a meter connected across the middle. When the ratio of the two ratio arms matches the ratio of the known arm to the unknown, the meter shows no deflection and the bridge is balanced. That null reading is what makes the method precise, because resistances are compared against each other rather than measured through a current. From the balance condition the unknown follows directly: divide the second ratio arm by the first and multiply by the known arm. With ratio arms of 100 and 200 and a known arm of 50, the ratio is 2 and the unknown is 100.

Checks that keep the answer honest

The result shows two cross products, the first ratio arm times the unknown and the second ratio arm times the known arm, and at balance they are equal; in the example both are 10000. A zero in any known arm is refused, since it leaves the ratio undefined or describes a short circuit, and values so tiny they are practically zero are treated the same way. Negative resistances are rejected because a passive bridge cannot have them. Keep in mind that the formula describes a bridge that is actually balanced, which is how null-deflection exercises in class are set up.

What you can do with it

Sensor and strain-gauge ratio design

Engineers pick ratio arms and a known resistor to target a desired sense-arm resistance before building the quarter-bridge hardware.

FAQ

What happens if any known resistance is zero?

A zero arm makes the ratio undefined or models a short, which is not a valid passive balanced measurement.

Does this solve an unbalanced bridge?

No. It assumes null balance and returns only the fourth arm. Unbalanced current or galvanometer deflection needs a different network analysis.

Is the Wheatstone bridge calculator free?

The browser tool is free and runs locally.

What is a Wheatstone bridge used for?

To find an unknown resistor by comparing it with known ones instead of relying on a precision ammeter. It also underpins strain-gauge and sensor circuits, where engineers choose the arms to target a desired sensing resistance.

Do the resistances have to be in ohms?

No. Any unit works as long as all three known values use the same one, for example ohms or kilohms. The unknown resistance comes back in that same unit, so there is nothing to convert.

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/elec/wheatstone-bridge

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/elec/wheatstone-bridge \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d '{"r1":100,"r2":200,"r3":50}'

const res = await fetch("https://api.kit.forhosting.com/elec/wheatstone-bridge", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.KIT_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "r1": 100,
    "r2": 200,
    "r3": 50
  })
});
const { task_id } = await res.json();

import os, requests

res = requests.post(
    "https://api.kit.forhosting.com/elec/wheatstone-bridge",
    headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
    json={
    "r1": 100,
    "r2": 200,
    "r3": 50
},
)
task_id = res.json()["task_id"]

<?php
$res = file_get_contents("https://api.kit.forhosting.com/elec/wheatstone-bridge", false, stream_context_create([
  "http" => [
    "method"  => "POST",
    "header"  => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
    "content" => '{"r1":100,"r2":200,"r3":50}',
  ],
]));
$task = json_decode($res, true);

body := bytes.NewBufferString(`{"r1":100,"r2":200,"r3":50}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/elec/wheatstone-bridge", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)

Example request

{
  "r1": 100,
  "r2": 200,
  "r3": 50
}

Example response

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

Limits

max_abs 1000000000000

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

Any zero among the known values is rejected with a clear invalid_input error because a zero arm makes the ratio undefined or models a short that is not a passive balanced measurement.

What a balanced Wheatstone bridge measures and why Rx = (R2/R1)·R3

Teachers and automated graders also care about the zero rejection: a student who types R1 equals zero has left the domain of a passive ratio bridge, and a silent Infinity would hide that mistake. Near-zero floating values at or below one times ten to the minus fifteen are treated as zero and rejected the same way so noise does not invent a huge ratio term.

How to call the API and what comes back

Every known arm must be strictly positive and non-zero; values whose absolute value is at or below one times ten to the minus fifteen are treated as zero and rejected, and negatives are rejected as non-physical for a passive bridge. Absolute values must stay within the published limit of one trillion so intermediate products remain finite in IEEE double precision on the Worker and in the browser. Failed validation—missing fields, non-finite numbers, zero or near-zero knowns, negatives, values outside absolute limits, or a non-finite Rx—returns invalid_input and is never charged. Pricing is a flat $0.002 per successful request with unit item and zero marginal unit price.

Practical tips, limits, and related searches

Keep every arm in the same unit before you call: mixing ohms with kilohms without converting will produce a nonsense Rx that looks numeric but is wrong by three orders of magnitude. Prefer sending numbers rather than pre-formatted engineering strings when you control the client; string numbers are accepted only when they match a strict finite numeric pattern. Prefer this capability when the bridge is already known to be balanced and you only need the fourth arm; if your lab still shows galvanometer deflection, adjust the known arm or ratio first until null, then call this tool. Failed tasks that return invalid_input do not consume prepaid balance, which keeps exploratory scripts cheap when learners deliberately type a zero.

Integration use cases

Lab report checks for null-balance experiments

Students enter measured R1, R2, and R3 from a balanced bridge and compare hand-written Rx and ratio against a deterministic browser or API result.

Unit tests for education apps and firmware

Generate known-good Rx values and deliberate zero rejections for coding kata expected JSON or embedded calculator fixtures.

Technical questions

What is the Wheatstone bridge formula for the unknown resistance?

For a balanced bridge with ratio arms R1 and R2 and known arm R3, the unknown is Rx = (R2 / R1) · R3, from the balance condition R1/R2 = R3/Rx.

Do R1, R2, and R3 need the same unit?

Yes. Supply all three in ohms, kilohms, or any single consistent unit; Rx is returned in that same unit.

Read the full KIT documentation →

Run — free