ForHosting KIT · Science

Solar panel calculator

Ten 400 W panels with 5 peak sun hours and 80% system efficiency make 16 kWh a day and 5840 kWh a year. Enter the numbers from the carton and your site to plan an array or check a quote. 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

Panel wattage: 400
Panel count: 10
Sun hours: 5
Efficiency: 0.8

You get

Array wattage: 4,000
Daily kwh: 16
Yearly kwh: 5,840

Homeowners, installers, and classroom energy units rarely start from irradiance and module area. They start from the sticker on the carton: four hundred watts, ten panels, five peak sun hours, and a system that is not one hundred percent efficient. This solar panel calculator turns those four planning numbers into daily and yearly kilowatt-hours with a closed product that every quote sheet already uses. Daily energy is nameplate wattage times panel count times daily sun hours times system efficiency, then divided by one thousand so watt-hours become kilowatt-hours. Yearly energy multiplies that daily figure by three hundred sixty-five.

What a solar panel energy estimate is and how daily and yearly kilowatt-hours are built

A solar panel energy estimate answers a planning question, not a laboratory power question. Given the nameplate wattage printed on each module, how many of those modules you will install, how many equivalent full-sun hours the site sees on an average day, and how much of the theoretical output survives inverter, wiring, soiling, and temperature losses, how many kilowatt-hours does the array deliver in a day and in a year?

Daily energy is the product of those four numbers divided by one thousand: wattage times count is array watts, array watts times sun hours is watt-hours, the performance ratio (system efficiency) scales that energy down to what AC meters actually see, and dividing by one thousand converts watt-hours into kilowatt-hours. Yearly energy multiplies the daily figure by three hundred sixty-five, a fixed planning year that does not consult a calendar or a leap-year table.

Example: four hundred watts, ten panels, five peak sun hours, and eighty percent system efficiency yields sixteen kilowatt-hours per day and five thousand eight hundred forty kilowatt-hours per year. Peak sun hours are not clock hours of daylight; they are the equivalent hours at one thousand watts per square metre that condensed the day's irradiance into a single number. System efficiency is a fraction, typically seven tenths to nine tenths, not a module conversion percentage already baked into the nameplate.

This page does not multiply irradiance by area to get instantaneous watts; that is a different search and a different product. Here the unit of value is energy over time, so a quote, a bill comparison, or a homework check can sit next to a kilowatt-hour figure instead of a snapshot in watts.

Who plans with daily and yearly kWh

Installers and design desks need a deterministic oracle that turns a carton sticker, a panel count, a peak-sun-hour table lookup, and a house performance ratio into daily and yearly kilowatt-hours without embedding a one-off spreadsheet in every quote tool. Homeowners comparing a ten-panel four-hundred-watt array against last year's bill want a number they can audit: sixteen kilowatt-hours a day at five sun hours and eighty percent efficiency, not a black-box simulation.

STEM classrooms and energy-literacy sites want students to separate nameplate watts from energy over time, and to see why a zero or negative input is an error instead of a silent zero that a buggy grader might treat as success. Automation pipelines that size residential arrays, seed homework answers, or sanity-check a customer form call the same contract so a demo and a backend never diverge.

Keep the four inputs positive, keep efficiency as a fraction not a percent, pin the rounded kilowatt-hours in tests, and you get reproducible daily and yearly energy figures for quotes, classrooms, and edge workers without standing up a weather-file stack of your own.

What you can do with it

Residential array quotes

Turn module wattage, panel count, site peak sun hours, and a performance ratio into daily and yearly kilowatt-hours for a first-pass quote.

Bill comparison for homeowners

Estimate how many kilowatt-hours a planned rooftop array would produce in a day and a year before comparing it with last year's usage.

Classroom energy oracles

Grade worksheets that convert nameplate watts into kilowatt-hours with a deterministic product that rejects zero and negative inputs.

FAQ

How is daily solar panel energy calculated?

Four hundred watts, ten panels, five peak sun hours, and 0.8 efficiency yield 16 kWh per day.

How is yearly energy calculated?

The same 16 kWh day is 5840 kWh per year. The 365-day factor is a fixed planning convention, not a leap-year or calendar lookup.

Is efficiency a percent or a fraction?

A fraction between 0 and 1 exclusive of zero. Use 0.8 for 80 percent. Values above 1 are rejected so a percent figure cannot inflate the energy eighty-fold.

How much energy do ten 400 W solar panels produce?

With 5 peak sun hours and a system efficiency of 0.8, ten 400 W panels form a 4000 W array that delivers 16 kWh a day and 5840 kWh over a year.

What are peak sun hours?

They are not the clock hours of daylight. They are the equivalent hours of full sun at 1000 W per square metre that sum up a day's sunlight, so a site with 5 peak sun hours gets that much full-strength light.

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/eco/solar-panel

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/eco/solar-panel \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d '{"panel_wattage":400,"panel_count":10,"sun_hours":5,"efficiency":0.8}'

const res = await fetch("https://api.kit.forhosting.com/eco/solar-panel", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.KIT_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "panel_wattage": 400,
    "panel_count": 10,
    "sun_hours": 5,
    "efficiency": 0.8
  })
});
const { task_id } = await res.json();

import os, requests

res = requests.post(
    "https://api.kit.forhosting.com/eco/solar-panel",
    headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
    json={
    "panel_wattage": 400,
    "panel_count": 10,
    "sun_hours": 5,
    "efficiency": 0.8
},
)
task_id = res.json()["task_id"]

<?php
$res = file_get_contents("https://api.kit.forhosting.com/eco/solar-panel", false, stream_context_create([
  "http" => [
    "method"  => "POST",
    "header"  => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
    "content" => '{"panel_wattage":400,"panel_count":10,"sun_hours":5,"efficiency":0.8}',
  ],
]));
$task = json_decode($res, true);

body := bytes.NewBufferString(`{"panel_wattage":400,"panel_count":10,"sun_hours":5,"efficiency":0.8}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/eco/solar-panel", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)

Example request

{
  "panel_wattage": 400,
  "panel_count": 10,
  "sun_hours": 5,
  "efficiency": 0.8
}

Example response

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

Any non-positive wattage, count, sun-hour total, or efficiency is rejected as invalid_input, so a missing plate or a sign error never invents free generation. The same pure arithmetic powers the free browser tool and the API at $0.002 per successful call.

Input contract, response fields, and error behaviour

Any input that is zero or negative is rejected with a message that a positive number is required, because a non-positive plate, count, sun-hour total, or derate is not a physical yield this estimator will invent. Efficiency above one is also rejected so entering eighty instead of 0.8 cannot inflate energy eighty-fold. Failed validation is not billed. Send a JSON body with four required finite positive numbers. panel_wattage is the STC nameplate of one module in watts (aliases: wattage, watts, panel_watts, module_watts, p, power). panel_count is how many modules sit in the array (aliases: count, panels, n, quantity, modules). sun_hours is the site's average daily peak sun hours (aliases: hours, daily_sun_hours, peak_sun_hours, psh, h). efficiency is the system performance ratio as a dimensionless fraction between zero and one exclusive of zero, for example 0.8 for eighty percent (aliases: system_efficiency, derate, performance_ratio, pr, eta). Values may arrive as JSON numbers or numeric strings. Missing fields, empty strings, and non-finite values fail with invalid_input naming the field. On success the body echoes the four rounded inputs, returns array_wattage as wattage times count, returns daily_kwh and yearly_kwh as the primary energy figures, and restates the two closed forms in a formula string. Pricing is a flat $0.002 per successful request with unit item. This endpoint does not look up weather files, does not derate for tilt or azimuth on your behalf, and does not convert currency or carbon.

Technical questions

What happens if an input is zero or negative?

The task fails with invalid_input. A non-positive wattage, panel count, sun-hour total, or efficiency is not a physical yield, so the estimator refuses to invent free energy and the call is not billed.

What does the solar panel calculator cost?

The browser tool is free. API requests use prepaid KIT balance at $0.002 per successful call; invalid input is not billed.

Read the full KIT documentation →

Run — free