Generator power calculator
A 230 V single-phase generator delivering 10 A at a power factor of 0.8 gives 1840 W, or 1.84 kW, of real power. Check a nameplate, a load-bank log or a homework answer for single-phase or three-phase sets. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Voltage
- 230
- Current
- 10
- Power factor
- 0.8
- Phases
- 1 W
- Phase multiplier
- 1
- Apparent power
- 2,300
- Power
- 1,840
A generator's electrical power output is not the product of voltage and current alone. Alternating-current machines deliver real watts equal to voltage times current times the power factor, and a three-phase set multiplies that product by the square root of three. Nameplates, load-bank tests, and homework all ask for that number in watts, not only the apparent volt-amperes sitting on the terminals.
What generator electrical power means and which quantities you need to send
Real electrical power at generator terminals is the portion of the volt-ampere product that does useful work, as opposed to the reactive exchange that inflates current without delivering watts. For a single-phase machine the identity is P equals V times I times PF, where V is terminal voltage in volts, I is line current in amperes, and PF is the dimensionless power factor between zero and one.
For a three-phase machine the same identity is multiplied by the square root of three when V is the line-to-line voltage, which is the figure printed on almost every industrial nameplate. Apparent power S equals k times V times I, and real power is that apparent power times the power factor, so a 0.8 lagging set delivers eighty percent of the volt-amperes as watts. Search intent clusters around generator power calculator, generator watts from voltage and current, three-phase generator power formula, and P equals root three V I PF.
People want a numeric watt figure they can check against a datasheet, a load-bank log, or a homework key—not only a reminder that the formula exists. Voltage is interpreted as line-to-neutral on a single-phase call and as line-to-line when phases is three. A two-hundred-thirty volt single-phase machine at ten amperes and a power factor of 0.8 yields one thousand eight hundred forty watts, a convenient check of the three-factor product.
How this calculator validates input and applies P = k · V · I · PF
Numeric strings that parse to finite numbers are accepted so forms and CSV-style pipelines can pass values without an extra cast. Voltage and current must be non-negative; a negative value is rejected with a clear message because a generator terminal voltage or line current below zero is not a physical operating point in this model. Zero voltage or zero current is allowed and yields zero watts.
Power factor must lie in the closed interval from zero to one inclusive: send 0.8 for eighty percent, not 80. Optional phases must be 1 or 3 and defaults to 1, so omitting it recovers the elementary identity P equals V times I times PF. There is no efficiency correction, no fuel curve, and no unit auto-conversion; this is ideal electrical real power from the stated terminal quantities.
Practical use, limits, pricing, and delivery channels
Use the browser tool when you want an immediate watt check while reading a generator nameplate, verifying a homework problem, sizing a feeder, or comparing two machines that share a voltage but run at different power factors. Results are fully deterministic: the same voltage, current, power factor, and phase count always yield the same watts. There is no language model, no external generator catalogue, and no randomness, so the capacity is safe to pin in continuous-integration checks and reproducible lesson materials.
Pair the result with a separate efficiency or fuel calculator when you need shaft input or litres per hour; this tool does not estimate diesel burn, temperature derating, or harmonic penalty from waveform distortion. Keep requests small, pin the rounded power field in tests, and you get reproducible generator watts for homework, design notebooks, and edge workers without standing up a full machine-modelling stack of your own.
What you can do with it
Nameplate and load-bank watt checks
Convert a generator's terminal voltage, measured line current, and nameplate power factor into real watts so feeder, breaker, and load selections start from a shared electrical-power number.
FAQ
Which formula does the generator power calculator use?
Apparent power S = k · V · I is returned alongside the watts.
What happens if voltage or current is negative?
Negative terminal voltage or line current is not allowed; those calls are not charged. Zero is accepted and yields zero watts.
What units should I send for voltage, current, and power factor?
Voltage must be in volts, current in amperes, and power factor as a fraction between 0 and 1 (0.8 not 80). For three-phase calls, send line-to-line voltage and set phases to 3.
What changes when I choose three-phase?
The product of voltage, current and power factor is multiplied by the square root of three. Enter the line-to-line voltage, which is the figure printed on almost every industrial nameplate, not the line-to-neutral one.
Why are the watts lower than volts times amps?
Volts times amps is the apparent power, and only the share set by the power factor does useful work. In the 230 V, 10 A example the apparent power is 2300 VA, and at 0.8 only 1840 W are real.
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/phys/generator-power \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"voltage":230,"current":10,"power_factor":0.8}'const res = await fetch("https://api.kit.forhosting.com/phys/generator-power", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"voltage": 230,
"current": 10,
"power_factor": 0.8
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/phys/generator-power",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"voltage": 230,
"current": 10,
"power_factor": 0.8
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/phys/generator-power", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"voltage":230,"current":10,"power_factor":0.8}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"voltage":230,"current":10,"power_factor":0.8}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/phys/generator-power", 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": 230,
"current": 10,
"power_factor": 0.8
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "phys.generator_power",
"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 generator power calculator accepts terminal voltage, line current, and power factor, optionally the phase count, and returns structured JSON with real power in watts, apparent power, the phase multiplier, and the closed-form identity used. Negative voltage or current is rejected as invalid_input.
What generator electrical power means and which quantities you need to send
Delivering voltage, current, power_factor, phases, phase_multiplier, apparent_power, power, power_kw, unit, formula, and method as JSON makes the result easy to paste into notes, pin in automated tests, or reuse across languages without reimplementing the square-root-of-three branch.
How this calculator validates input and applies P = k · V · I · PF
Send a JSON body with voltage, current, and power_factor. All three fields are required and must be finite: missing any field, empty strings, non-numeric text, NaN, and Infinity all fail immediately with invalid_input before any result is returned, and failed validation is not charged. Aliases are recognized for convenience: voltage also accepts V, volts, voltage_v, terminal_voltage, and line_voltage; current also accepts I, amps, amperes, current_a, and line_current; power_factor also accepts pf, PF, cos_phi, cosphi, and powerfactor. After validation, phase_multiplier is 1 or the square root of three, apparent_power is that multiplier times voltage times current, and power is apparent_power times power_factor. Results are rounded to twelve decimal places so the same input always yields the same JSON across JavaScript engines.
Practical use, limits, pricing, and delivery channels
Each successful request is one billable item at $0.002; failed validation does not consume balance. Choose units consistently—if voltage is in volts and current is in amperes, power is true SI watts and apparent_power is volt-amperes. Wire the endpoint into load-bank worksheets, contest answer checkers, or preprocessing steps where you already prefer explicit domain errors—such as rejecting negative voltage—over opaque black-box widgets that cannot explain why a bad input was refused.
Integration use cases
Homework and lab AC-power drills
Students and graders confirm P = k·V·I·PF for single-phase and three-phase sets, with a clear invalid_input rejection when voltage or current is negative.
Deterministic fixtures for generator tests
Pipelines that seed unit tests or interactive commissioning demos can call a pure V-I-PF oracle instead of reimplementing the square-root-of-three branch in every language.
Technical questions
How do I compute generator power with this API?
Send a JSON body with voltage in volts, current in amperes, and power_factor in [0, 1] to phys.generator_power. Optional phases is 1 or 3 (default 1). The response returns power in watts, power_kw, apparent_power, phase_multiplier, unit, formula, and method.
What does the generator power calculator cost?
The browser tool is free. API requests use prepaid KIT balance at $0.002 per successful call; invalid input is not billed.