Capacitive voltage divider
10 V across two equal 1 nF capacitors leaves 5 V on the lower one, a ratio of 0.5 and about −6 dB. Enter the input voltage and both capacitances in one unit; the smaller capacitor always takes the larger share. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Vin
- 10
- C1
- 0.000000001
- C2
- 0.000000001
- C sum
- 0.000000002
- C series
- 0.0000000005
- Vout
- 5
- Ratio
- 0.5
A capacitive voltage divider splits an AC input voltage across two capacitors connected in series. Because capacitive reactance is inversely proportional to capacitance, the larger share of voltage appears across the smaller capacitor — the dual of a resistive divider where voltage tracks resistance. This capacitive voltage divider calculator takes the input voltage Vin plus the upper series capacitance C1 and the lower sense capacitance C2, then returns the mid-node output Vout across C2, the division ratio, the series equivalent capacitance, and attenuation in decibels. High-voltage probes, AC coupling networks, capacitive touch sense front-ends, and classroom impedance labs all use the same closed form. Requests with non-positive capacitances fail with a clear validation error instead of dividing by zero.
How the two-capacitor capacitive divider works
Place two ideal capacitors C1 and C2 in series across an AC source Vin. The upper plate of C1 sees Vin, the junction between C1 and C2 is the mid-node, and the far side of C2 returns to the source reference. Output voltage Vout is taken from the mid-node to reference, which is the voltage across C2.
At any single frequency the reactances are Xc1 equals one over omega C1 and Xc2 equals one over omega C2. A series voltage divider with those impedances gives Vout equals Vin times Xc2 over Xc1 plus Xc2. Substituting the reactance expressions, omega cancels, and the result collapses to Vout equals Vin times C1 over C1 plus C2.
In words, each capacitor voltage is inverse to its own capacitance, so the smaller capacitor takes the larger share of Vin. The series equivalent capacitance is C1 times C2 over C1 plus C2, the same identity used when reducing two series caps for net impedance. Those identities are exact for lumped linear capacitors with negligible ESR and leakage; real parts add tolerance, voltage coefficients, and parasitics to ground, but the first design step is still this algebraic split.
Empty or non-finite fields fail validation. Zero or negative capacitance fails because passive capacitors cannot contribute non-positive C.
What you send and what you get back
Send three finite numbers: vin in volts for the AC input across the series pair, c1 for the upper series capacitance, and c2 for the lower sense capacitance across which Vout is measured. Capacitance values must share one unit — farads, microfarads, nanofarads, or picofarads — because only the ratio C1 over C1 plus C2 matters for voltage. Both capacitances must be strictly positive.
Missing fields, non-numeric strings, NaN, and Infinity also fail and are not charged. Classic classroom checks include ten volts into equal one-nanofarad capacitors, which should give five volts out with ratio one half and minus six decibels of attenuation.
Where capacitive divider calculators show up in real work
Introductory AC circuit courses assign capacitive-divider drills right after series capacitors and before full phasor analysis, so students need a trusted oracle that returns Vout, ratio, and series equivalent they can compare with an oscilloscope reading in lab. Power-electronics and instrumentation teams design high-voltage AC sense dividers with a small series C1 and a larger shunt C2 so the mid-node stays inside an ADC or op-amp range without resistive loading that would burn watts at high voltage.
RF and mixed-signal boards use capacitive coupling chains to set bias-independent attenuation into receivers or level detectors. Firmware bring-up for capacitive touch or proximity front-ends often needs the unloaded divider ratio before parasitic pads and firmware filters enter the model. Repair technicians diagnosing a failed sense network ask what mid-node voltage the original C values should have produced, and a closed-form answer is faster than spinning a full SPICE deck for two ideal caps.
Keep resistive voltage dividers, current dividers, and plain series-capacitance totals on separate landings so each search intent has one clear page rather than an overloaded multi-topology tool that confuses both students and search engines.
What you can do with it
Lab homework and scope checks
Compute expected mid-node Vout for two series capacitors so students can compare calculator results with oscilloscope readings on a breadboard AC source.
High-voltage AC sense dividers
Size series C1 and shunt C2 so a high AC line voltage is attenuated into a safe ADC or isolation amplifier range without continuous resistive power loss.
FAQ
What formula does this capacitive voltage divider calculator use?
For two series capacitors with Vout across C2, Vout = Vin × C1 / (C1 + C2). Voltage is inverse to capacitance because Xc ∝ 1/C and frequency cancels in the ratio.
Does frequency matter?
For ideal capacitors the voltage ratio is frequency-independent: omega cancels when you form Xc2 / (Xc1 + Xc2). Real ESR, ESL, and load impedance can reintroduce frequency dependence outside this model.
What units should I use for C1 and C2?
Any consistent unit — F, µF, nF, or pF — because only the ratio matters. The response labels capacitance unit as farads for the numeric values you send.
How is this different from a resistive voltage divider?
A capacitive divider uses Vout = Vin × C1 / (C1 + C2) for Vout across C2. Different search intent, different topology, separate landing.
What does it cost?
The browser tool is free and runs locally.
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/capacitive-divider \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"vin":10,"c1":1e-9,"c2":1e-9}'const res = await fetch("https://api.kit.forhosting.com/elec/capacitive-divider", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"vin": 10,
"c1": 1e-9,
"c2": 1e-9
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/elec/capacitive-divider",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"vin": 10,
"c1": 1e-9,
"c2": 1e-9
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/elec/capacitive-divider", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"vin":10,"c1":1e-9,"c2":1e-9}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"vin":10,"c1":1e-9,"c2":1e-9}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/elec/capacitive-divider", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"vin": 10,
"c1": 1e-9,
"c2": 1e-9
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "elec.capacitive_divider",
"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
How the two-capacitor capacitive divider works
The critical singularity is a vanishing sum C1 plus C2, which would divide by zero and is rejected with invalid_input rather than returning NaN or infinity.
What you send and what you get back
The voltage field also accepts aliases v_in, input_voltage, or v_input, and the capacitances accept C1, cap1, or series_c and C2, cap2, or shunt_c, but only one name per role may appear so the contract stays unambiguous for widgets and SDK clients. When either is zero or negative, or their sum is approximately zero, the request fails with invalid_input and a message that explains the constraint. On success the response echoes cleaned vin, c1, and c2, reports c_sum and c_series, returns vout and ratio, includes attenuation_db as twenty times log base ten of the ratio when the ratio is positive, labels units as volts and farads, and records method capacitive_divider with the formula string. Pricing for successful API calls is the published base of $0.002 per item; validation failures do not consume prepaid balance.
Where capacitive divider calculators show up in real work
Because this capability is a pure parse engine, API pricing is the published base of $0.002 per successful item and failed validation does not consume balance.
Integration use cases
Coupling and fixture regression
Script the same divider formulas used in the browser so CI fixtures assert that programmed capacitor pairs still match the design document attenuation.