Kirchhoff voltage law calculator
A 12 V source feeding a 5 V drop and one unknown drop leaves 7 V for the unknown. List the voltages around one closed loop, tag each as rise or drop, leave one blank, and get the value that brings the sum to zero. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Kirchhoff's voltage law states that the algebraic sum of voltages around any closed electrical loop is zero. Designers, students, and automation scripts use that identity every time a single mesh has one unknown source or drop and the rest of the path is known.
Walking around a loop, one sign at a time
Kirchhoff's voltage law says that if you walk once around any closed path in a circuit and return to the starting node, the voltages you meet add up to zero. Pick a direction and keep it. An element that raises the potential in that direction counts as positive and a drop counts as negative; the reverse convention works just as well, as long as you never switch halfway round. With every voltage known except one, the loop becomes a simple equation: the unknown equals minus the sum of the signed known values, divided by its own sign. In the example, a 12 V rise and a 5 V drop leave 7 V for the remaining drop, and the rebuilt loop sum comes out at 0.
Mistakes that break the balance
Most wrong answers come from the tags, not from the arithmetic. Marking a drop as a rise flips its sign, and the unknown no longer matches the circuit. Leaving two values blank makes the loop underdetermined, which is why the calculator asks for exactly one unknown. Mixing units gives a meaningless sum: any consistent unit works, and volts are the usual choice. Finally, this tool covers one loop only. It does not run nodal or mesh analysis on a network with several loops, does not invent branch currents and does not choose polarities for you, so the order and the tags you enter must match the direction you picked.
What Kirchhoff's voltage law means on a single mesh
When you walk once around a closed path in a circuit and return to the same node, the net change in electric potential must be zero. That statement is Kirchhoff's voltage law (KVL). A voltage rise in the walk direction contributes a positive term; a voltage drop contributes a negative term (or the opposite convention if you reverse the walk—the physics is the same as long as you stay consistent).
On a single loop this becomes a linear equation with as many terms as elements you listed. If all magnitudes but one are known, the equation determines the missing magnitude uniquely: the unknown voltage equals the negative of the sum of the signed knowns divided by the sign of the unknown contribution.
Each record needs contribution set to rise or drop. Provide a finite voltage for every known term; omit voltage, pass null, or set unknown true on exactly one element—the unknown to solve. Optional name labels appear in the response terms list for teaching and UI.
Magnitudes share any consistent unit—volts are the usual choice—and the unit field in the response is V for labeling only.
What you can do with it
Classroom single-loop homework checks
Students list series sources and drops with rise/drop tags, leave one blank, and verify the unknown voltage against textbook KVL methods.
Exam and LMS auto-grading
Mark single-mesh KVL items with a deterministic oracle that requires exactly one unknown and rejects underdetermined loops.
Field tracing of battery-and-load paths
Technicians enter measured branch voltages around one path and solve the remaining drop without opening a full circuit simulator.
FAQ
How do I solve an unknown voltage with Kirchhoff's voltage law?
Send an elements array for one closed loop. Tag each item contribution as rise or drop, give a finite voltage for every known term, and omit voltage on exactly one unknown.
What do rise and drop mean?
They are relative to the loop direction you chose. A rise adds +voltage to the sum; a drop adds −voltage. Stay consistent for the whole walk—reversing the walk flips every tag but yields the same unknown magnitude.
Why is exactly one unknown required?
A single loop gives one independent KVL equation. Zero unknowns is just a check you can do offline; two or more unknowns underdetermine the mesh. This calculator always solves for one magnitude.
Does this handle multi-loop mesh analysis?
No. It applies KVL to one ordered list of voltages. Multi-loop systems need simultaneous equations or a full network solver; send each simple loop separately if you already reduced the rest.
How many elements can one loop contain?
Between 2 and 40. List them in the order you meet them as you walk around the loop, tag each one as a rise or a drop, and leave exactly one voltage blank for the calculator to solve.
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/elec/kirchhoff-voltage-law \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"elements":[{"name":"Vs","voltage":12,"contribution":"rise"},{"name":"VR1","voltage":5,"contribution":"drop"},{"name":"VR2","contribution":"drop"}]}'const res = await fetch("https://api.kit.forhosting.com/elec/kirchhoff-voltage-law", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"elements": [
{
"name": "Vs",
"voltage": 12,
"contribution": "rise"
},
{
"name": "VR1",
"voltage": 5,
"contribution": "drop"
},
{
"name": "VR2",
"contribution": "drop"
}
]
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/elec/kirchhoff-voltage-law",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"elements": [
{
"name": "Vs",
"voltage": 12,
"contribution": "rise"
},
{
"name": "VR1",
"voltage": 5,
"contribution": "drop"
},
{
"name": "VR2",
"contribution": "drop"
}
]
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/elec/kirchhoff-voltage-law", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"elements":[{"name":"Vs","voltage":12,"contribution":"rise"},{"name":"VR1","voltage":5,"contribution":"drop"},{"name":"VR2","contribution":"drop"}]}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"elements":[{"name":"Vs","voltage":12,"contribution":"rise"},{"name":"VR1","voltage":5,"contribution":"drop"},{"name":"VR2","contribution":"drop"}]}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/elec/kirchhoff-voltage-law", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"elements": [
{
"name": "Vs",
"voltage": 12,
"contribution": "rise"
},
{
"name": "VR1",
"voltage": 5,
"contribution": "drop"
},
{
"name": "VR2",
"contribution": "drop"
}
]
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "elec.kirchhoff_voltage_law",
"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 Kirchhoff voltage law loop calculator accepts an ordered list of elements for one traversal direction, tags each as a voltage rise or drop, leaves exactly one magnitude blank, and returns the voltage that closes ΣV = 0. Failed validation is invalid_input and is not billed; successful calls stay at the published $0.002 base price with no model tokens and no outbound network.
What Kirchhoff's voltage law means on a single mesh
In practice you choose a traversal direction, assign every source or resistor voltage a signed contribution relative to that walk, and write ΣV = 0. This capability encodes that classroom identity as a deterministic parse API. It does not perform full nodal or mesh analysis of multi-loop networks, does not invent branch currents, and does not assign polarities for you—you supply the ordered list and the rise/drop tags that match your chosen direction. That focus keeps the contract small, the browser path free, and the result reproducible across runtimes without floating-point surprises beyond stable twelve-decimal rounding of the solved value and the reconstructed loop sum.
Input contract, signs, and response shape
POST a JSON body with one required field: elements (aliases voltages, loop, terms), an array of at least two and at most forty records. On success the body echoes element_count; names the unknown with unknown_name, unknown_index, unknown_contribution, and unknown_voltage; reports known_sum (sum of signed knowns before solving) and loop_sum (algebraic sum after substitution, which rounds to zero when the data are consistent); and lists terms with name, voltage, contribution, signed value, and an unknown flag on the solved row. formula and method restate the identity for display. Example: a twelve-volt source tagged rise, a five-volt drop, and an unknown drop yields unknown_voltage seven volts because plus twelve minus five minus V equals zero. Errors include fewer than two elements, zero or multiple unknowns, non-finite numbers, and invalid contribution tokens; those fail with invalid_input and do not consume balance.
Where a single-loop KVL calculator earns its keep
Circuit labs and tutoring platforms use a Kirchhoff voltage law calculator so learners can check one unknown on a series loop without flipping the sign of every drop by hand. Exam generators and LMS plugins need a deterministic oracle that rejects two blanks as invalid rather than silently picking an underdetermined mesh. Field technicians and makers tracing a battery-plus-loads path often know every drop but one and want the remaining voltage quickly on a phone browser before writing it on a schematic. Embedded scripts in notebooks can call the API at $0.002 per successful item to pin goldens for lab write-ups without standing up a full SPICE engine for a three-term sum. Keep the element list short, pin the rounded unknown_voltage and loop_sum in tests, and you get reproducible mesh closure for homework, widgets, and edge workers.
Technical questions
What does the Kirchhoff voltage law calculator cost?
The browser tool is free. API requests use prepaid KIT balance at $0.002 per successful call; invalid input is not billed.