This accounts for motors in appliances like refrigerators or AC units.
This is the sum of watts for appliances that will run simultaneously.
120V
240V
208V
480V
Single Phase
Three Phase
Recommended to add a buffer for unexpected loads.
Recommended Generator Size:
Watts Amps
(Approximate)
Understanding Generator Sizing for Your Needs
Choosing the right size generator is crucial for ensuring reliable backup power during outages. An undersized generator may not be able to handle your essential loads, leading to frustration and potential damage to appliances. An oversized generator, on the other hand, can be unnecessarily expensive to purchase and operate, and may not run efficiently at lower loads.
This calculator helps you determine the appropriate Generac generator size by considering your specific electrical demands. We'll break down the key factors involved in the calculation.
Key Factors for Sizing:
Starting Wattage (Surge Watts): Many appliances, especially those with motors (like refrigerators, air conditioners, sump pumps, and power tools), require a significant surge of power to start up. This "starting wattage" can be 2 to 3 times (or even more) than their normal running wattage.
Continuous Wattage (Running Watts): This is the wattage an appliance consumes while it is running normally. You need to sum the continuous wattage of all appliances you anticipate running simultaneously during an outage.
Total Running Load: This is the sum of the continuous wattage of all essential appliances you want to power at the same time.
Total Starting Load: This is the highest wattage demand needed to start any one appliance, added to the total continuous wattage of all other appliances that will be running concurrently.
Voltage and Phase: These electrical specifications are important for matching the generator to your home's electrical system. Most homes are 120/240V single-phase, but some larger homes or commercial applications may use three-phase power.
Safety Margin: It's always wise to add a buffer (e.g., 25%) to your calculated needs. This accounts for the potential for unexpected appliance startups, future additions to your load, and ensures the generator isn't constantly running at its maximum capacity, which can reduce its lifespan.
How the Calculator Works:
The Generac Generator Sizing Calculator estimates your required generator capacity using the following logic:
Calculate Total Continuous Watts: Sum the continuous wattage of all essential appliances you plan to run simultaneously. This is often represented by the `Continuous Running Wattage Needed` field.
Calculate Total Starting Watts: Identify the appliance with the highest starting wattage requirement. The calculator uses the `Additional Starting Wattage Needed` to represent this peak demand, assuming it's the largest surge required *beyond* the running loads.
Determine Peak Demand: The highest demand will either be the total continuous running watts or the total continuous running watts plus the single largest starting surge. The calculator aims to cover this peak demand.
Apply Safety Margin: The calculated peak demand is then increased by the specified safety margin (e.g., 25%) to arrive at the final recommended generator size in watts.
Calculate Amperage: Using the final recommended wattage and the selected voltage and phase, the calculator estimates the required amperage. For single-phase, Amps = Watts / Volts. For three-phase, Amps = (Watts / (Volts * sqrt(3))) * 2. (Note: For simplicity, this calculator uses the single-phase formula for amperage calculation, as it's the most common scenario for residential backup. For precise three-phase calculations, consult an electrician.)
By inputting your specific appliance requirements, this calculator provides a strong starting point for selecting a Generac generator that will reliably power your home during unexpected outages. Always consult with a qualified electrician or Generac dealer for a professional assessment of your specific needs.
function calculateGeneratorSize() {
var totalAppliancesWattsInput = document.getElementById("totalAppliancesWatts");
var startingWattsInput = document.getElementById("startingWatts");
var continuousWattsInput = document.getElementById("continuousWatts");
var voltageInput = document.getElementById("voltage");
var phaseInput = document.getElementById("phase");
var safetyMarginInput = document.getElementById("safetyMargin");
var resultDiv = document.getElementById("result");
var calculatedWattsSpan = document.getElementById("calculatedWatts");
var calculatedAmpsSpan = document.getElementById("calculatedAmps");
// Clear previous results
resultDiv.style.display = "none";
calculatedWattsSpan.textContent = "";
calculatedAmpsSpan.textContent = "";
// Get input values and convert to numbers
var totalAppliancesWatts = parseFloat(totalAppliancesWattsInput.value);
var startingWatts = parseFloat(startingWattsInput.value);
var continuousWatts = parseFloat(continuousWattsInput.value);
var voltage = parseFloat(voltageInput.value);
var phase = parseFloat(phaseInput.value);
var safetyMarginPercent = parseFloat(safetyMarginInput.value);
// Validate inputs
if (isNaN(totalAppliancesWatts) || totalAppliancesWatts < 0 ||
isNaN(startingWatts) || startingWatts < 0 ||
isNaN(continuousWatts) || continuousWatts < 0 ||
isNaN(voltage) || voltage <= 0 ||
isNaN(phase) || phase <= 0 ||
isNaN(safetyMarginPercent) || safetyMarginPercent < 0) {
alert("Please enter valid positive numbers for all wattage and margin inputs, and select valid voltage/phase.");
return;
}
// — Core Calculation Logic —
// Determine the highest wattage needed. This is either the continuous running load
// or the continuous running load plus the largest starting surge.
// For simplicity and practical application, we often consider the total continuous load
// plus the largest single starting surge needed.
// However, the user provides "Total Appliances Watts" and "Additional Starting Watts".
// A common approach is to sum the continuous loads of all appliances you want to run simultaneously
// and then add the *largest* starting surge of *one* of those appliances.
// The inputs provided allow for this interpretation.
// Let's refine the interpretation:
// `continuousWatts` = Sum of watts for items running simultaneously.
// `startingWatts` = The *additional* surge needed for the largest starting motor *on top of* its running watts,
// or the total surge if that's what the user intends to input.
// A more robust approach considers appliance by appliance, but we must work with given inputs.
// We'll assume `continuousWatts` is the base load, and `startingWatts` is the surge for *one* item
// that pushes the total higher.
var calculatedContinuousLoad = continuousWatts;
var peakDemand = calculatedContinuousLoad + startingWatts;
// Handle cases where starting watts might be less than continuous, but still crucial.
// The actual peak is the higher of (continuous load) OR (continuous load + starting surge).
// However, the user explicitly provides "Additional Starting Wattage". A safer approach is:
// Sum of running watts + the largest starting surge.
// If user inputs `continuousWatts` as "total running load" and `startingWatts` as the "peak surge needed from one appliance",
// then peak demand is `continuousWatts` + `startingWatts`.
// A more conservative and common approach in DIY sizing is:
// 1. Sum of ALL continuous watts.
// 2. Find the appliance with the HIGHEST STARTING surge.
// 3. The required generator size is: (Sum of continuous watts – running watts of the largest surge appliance) + (Starting watts of the largest surge appliance).
// OR often simplified to: Total Continuous Watts + Largest Starting Surge.
// Given the specific input names:
// `totalAppliancesWatts`: This is ambiguous. Is it a sum of *all* potential appliances, or just the ones intended to run together?
// `continuousWatts`: Seems to be the intended load *when running*.
// `startingWatts`: Seems to be the *additional* surge.
// Let's use a common simplified model:
// Base Load = continuousWatts
// Surge Load = startingWatts (assuming this is the biggest surge needed)
// Total Required Peak = Base Load + Surge Load
// If startingWatts is less than continuousWatts, we still need to ensure the continuous load is met.
var requiredPeakWatts = Math.max(continuousWatts, calculatedContinuousLoad + startingWatts);
// However, if startingWatts is purely the *additional* surge, then:
requiredPeakWatts = continuousWatts + startingWatts;
// Let's clarify with the user's intention of `totalAppliancesWatts`.
// If `totalAppliancesWatts` is meant to be the sum of *all* appliances they want to power,
// and `continuousWatts` is a subset of that which will run simultaneously, and `startingWatts` is the largest surge:
// Then the peak demand is `continuousWatts` + `startingWatts`.
// If `totalAppliancesWatts` is the true sum of everything, and `continuousWatts` is what runs together,
// and `startingWatts` is the largest surge… this gets confusing without appliance lists.
// The most practical interpretation for these three wattage fields combined is:
// `continuousWatts` = The sum of watts for appliances that will run *simultaneously*.
// `startingWatts` = The *extra* surge needed for the largest motor appliance on top of its running watts.
// `totalAppliancesWatts` = This input might be redundant or intended as a rough estimate. We'll prioritize `continuousWatts` and `startingWatts` for peak calculation.
var calculatedPeakDemand = continuousWatts + startingWatts;
// Ensure the continuous load is always met, even if starting surge is smaller
if (calculatedPeakDemand 0) {
if (phase === 1) { // Single Phase
calculatedAmps = finalRequiredWatts / voltage;
} else if (phase === 3) { // Three Phase – Simplified approximation
// For three-phase, Watts = Volts * Amps * sqrt(3) * PowerFactor
// Assuming PowerFactor = 1 for simplicity in estimation
// Amps = Watts / (Volts * sqrt(3))
calculatedAmps = finalRequiredWatts / (voltage * Math.sqrt(3));
}
calculatedAmps = calculatedAmps.toFixed(2); // Display amps with 2 decimal places
}
calculatedWattsSpan.textContent = finalRequiredWatts.toLocaleString(); // Format with commas
calculatedAmpsSpan.textContent = calculatedAmps;
resultDiv.style.display = "block";
}