ForHosting KIT · Engineering & construction

Inductor current ripple calculator

With 12 V across a 0.0001 H inductor, a duty cycle of 0.4 and 100 kHz switching, the current swings 0.48 A peak to peak. Enter those four values, duty as a fraction, to size a buck or boost choke. 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

Voltage: 12
Inductance: 0.0001
Duty cycle: 0.4
Switching frequency: 100,000

You get

Current ripple: 0.48 A
Precision: 10

This inductor current ripple calculator finds the peak-to-peak current swing in a switching converter inductor when you know the voltage across the winding during a constant-voltage ramp, the inductance, the duty cycle, and the switching frequency. When voltage is in volts, inductance in henries, duty cycle as a fraction, and frequency in hertz, the result is reported in amperes. Zero duty or zero voltage is valid and yields zero ripple; inductance and frequency must be strictly positive; duty cycle must lie in the unit interval from zero to one; a negative voltage is rejected because this tool uses the ramp magnitude. The engine is fully deterministic arithmetic: no network calls, no sampling, and no date-dependent shortcuts.

What the ripple figure means and what you get

In continuous-conduction switching converters, the inductor current ramps up and down each switching period under approximately constant voltages during the on and off intervals. The voltage you supply is the magnitude across the inductor for the interval you choose to model: for a buck converter on-time that is often V_in minus V_out; for the off-time it is typically the output voltage with the freewheel path.

Because volt-second balance forces the absolute ramp magnitudes to match in steady state, either interval yields the same ΔI when the correct V and complementary duty are used consistently. Current ripple is not average load current, not RMS winding current, and not the energy stored as one-half L I squared: it is the triangular (or trapezoidal) peak-to-peak swing that drives core loss estimates, output capacitor ripple current, and continuous-versus-discontinuous mode boundaries. Zero voltage or zero duty is valid and yields zero ripple when the other factors remain finite and legal.

What you can do with it

Buck and boost choke sizing

Compute peak-to-peak ΔI = V·D/(L·f) from ramp voltage, inductance, duty, and switching frequency before choosing a power inductor.

Homework and lab checks

Verify continuous-conduction ripple targets on worksheets and lab reports without hand-calculating volt-second ramps each time.

FAQ

What does the inductor current ripple calculator cost?

It is free in your browser on this page.

What formula is used for peak-to-peak inductor current ripple?

With SI inputs (volts, henries, fraction duty, hertz) the unit is amperes (A).

Which voltage should I enter for a buck converter?

For the on-time ramp use V = V_in − V_out (and the on duty D). For the off-time ramp use V = V_out with duty (1 − D). In steady state both give the same ΔI when used consistently.

Is duty cycle entered as a percent or a fraction?

As a fraction in [0, 1]. Forty percent duty is 0.4, not 40.

Is this the same as inductor energy E = ½LI²?

No. Inductor energy is magnetic storage from inductance and a current value. This tool computes peak-to-peak switching current ripple from voltage, L, duty, and frequency. Use the inductor energy calculator when you need joules from L and I.

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/inductor-current-ripple

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/inductor-current-ripple \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d '{"voltage":12,"inductance":0.0001,"duty_cycle":0.4,"switching_frequency":100000}'

const res = await fetch("https://api.kit.forhosting.com/elec/inductor-current-ripple", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.KIT_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "voltage": 12,
    "inductance": 0.0001,
    "duty_cycle": 0.4,
    "switching_frequency": 100000
  })
});
const { task_id } = await res.json();

import os, requests

res = requests.post(
    "https://api.kit.forhosting.com/elec/inductor-current-ripple",
    headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
    json={
    "voltage": 12,
    "inductance": 0.0001,
    "duty_cycle": 0.4,
    "switching_frequency": 100000
},
)
task_id = res.json()["task_id"]

<?php
$res = file_get_contents("https://api.kit.forhosting.com/elec/inductor-current-ripple", false, stream_context_create([
  "http" => [
    "method"  => "POST",
    "header"  => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
    "content" => '{"voltage":12,"inductance":0.0001,"duty_cycle":0.4,"switching_frequency":100000}',
  ],
]));
$task = json_decode($res, true);

body := bytes.NewBufferString(`{"voltage":12,"inductance":0.0001,"duty_cycle":0.4,"switching_frequency":100000}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/elec/inductor-current-ripple", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)

Example request

{
  "voltage": 12,
  "inductance": 0.0001,
  "duty_cycle": 0.4,
  "switching_frequency": 100000
}

Example response

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

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

The closed form is ΔI equals V times D divided by L times f_sw, which follows directly from the inductor law V equals L di/dt over on-time t_on equals D over f_sw.

What peak-to-peak inductor current ripple means and what the response contains

Integrating V equals L di/dt over the on-time t_on equals D over f_sw gives the peak-to-peak excursion ΔI_pp equals V times D divided by L times f_sw. This calculator returns the normalized inputs voltage, inductance, duty_cycle, and switching_frequency, the computed current_ripple, the precision used, a method tag inductor_current_ripple, a short formula reminder, and a unit hint A for SI inputs. There is no topology auto-detection, no multi-phase interleaving model, and no Monte Carlo sampling: the engine either evaluates V·D/(L·f) inside the supported numeric range or rejects the input with invalid_input. Rejected cases include missing required fields, non-finite values, magnitudes above the documented ceilings, inductance or frequency that are not strictly positive, duty cycle outside the closed unit interval, and any negative voltage.

How inputs are read and how the ripple result stays reproducible

Zero voltage is allowed and returns zero ripple. Optional leading plus signs and scientific notation on numeric strings are allowed when they parse as finite decimals; embedded spaces and non-numeric tokens are rejected. The preferred field for the ramp voltage is voltage, but aliases V, v, and volts are accepted so spreadsheets, query strings, and typed forms can reuse the same contract. Voltage must be finite and non-negative: a negative value fails with invalid_input and a message that names the field and explains that peak-to-peak ripple uses the magnitude during the ramp, so a bad cell does not become a silent nonsense result. The preferred field for inductance is inductance, with aliases L, l, henries, and henry; inductance must be strictly greater than zero because division by L is undefined at zero and a negative L is not accepted. Duty cycle uses duty_cycle with aliases D, d, and duty, and must be a fraction in the closed interval from zero to one inclusive—not a percentage—so forty percent is entered as 0.4. Switching frequency uses switching_frequency with aliases f, f_sw, frequency, and freq, and must be strictly positive. An optional precision field, with aliases decimals and dp, chooses how many decimal places to expose for the numeric outputs, defaulting to ten and capped at fifteen so JSON goldens stay stable. 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 inductor current ripple formula yourself.

Where inductor current ripple fits in study, design, and software

Students meet ΔI equals V D over L f when a textbook introduces continuous conduction mode, when a homework problem asks for peak-to-peak inductor current from millihenries and kilohertz, or when a lab report must show that the designed choke stays above a ripple target at full load. Teachers can pre-generate answer keys for modest converter parameters without trusting opaque calculator apps that silently switch percent duty for fraction duty or confuse microhenries with henries. Developers call the same contract from scripts to seed deterministic test vectors for power-electronics demos, to normalize user-entered choke parameters before an energy or loss budget, or to satisfy programming-challenge statements that demand amperes of ripple rather than a hand-waved sketch. Product and first-order electrical checks use this form when only inductor voltage during the ramp, L, D, and f_sw are known before core loss maps, saturation curves, or multi-phase current sharing are modeled. Education tools use the endpoint when a learner types converter parameters and the UI must show peak-to-peak amperes. 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 inductor energy or inductive-reactance helpers when you need related magnetic quantities, and with other electronics endpoints when you are building a small lab of free, deterministic converter calculators.

Integration use cases

Deterministic test fixtures

Generate reproducible current-ripple values for unit tests, power-electronics demos, and CI assertions on ΔI_pp.

Read the full KIT documentation →

Run — free