# Solar Panel Calculator: System Size, Production, Battery Bank (`jumblemog/solar-panel-calculator`) Actor

Solar PV systems from plain text for any place: the system size for your power use or bill, kWh by month from NASA sunlight data, panels, roof area and payback; off-grid battery bank, panels, controller and inverter.

- **URL**: https://apify.com/jumblemog/solar-panel-calculator.md
- **Developed by:** [Jumble Mog](https://apify.com/jumblemog) (community)
- **Categories:** AI, Automation, Developer tools
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Solar Panel Calculator: System Size, Production, Battery Bank

**How big a solar system you need, what it makes each month and when it pays back, or the battery bank and panels for an off-grid cabin or RV, from one line of text.** Describe the place and the use (`how big a solar system for 900 kWh a month in Denver`, `6 kW system in Austin, Texas facing south, 6/12 roof, $2.80/W, 14 cents/kWh` or `off-grid cabin in Flagstaff: fridge 60 W 24 h, lights 40 W 5 h, laptop 60 W 4 h`) and you get back:

- **The system size**: kW, the number of panels, the panel and roof area, and the inverter size, for your yearly or monthly use, your electricity bill or a share of it (`80% offset`).
- **Production by month**: kWh each month from 25 years of NASA satellite sunlight and temperature for the place, with the sunlight on the panels at your tilt and facing, the cell temperature and the yearly kWh per kW.
- **The best tilt** for the place and how much yours gives of it.
- **Money**: yearly savings at your rate, cost per watt, incentives, payback years and 25-year savings.
- **Off-grid systems**: the daily load (from a list of appliances or a total), the battery bank in kWh and Ah at 12, 24 or 48 V (lithium or lead-acid, with days of autonomy), the panels for the darkest month you use it, the MPPT charge controller and the inverter.
- **A chart**: energy by month against your use or load, and the sunlight on the panels against flat ground.

It's made for:

- Homeowners checking a solar quote: is the size right, what will it make, when does it pay back.
- Solar installers and sales teams sizing systems from a customer's bill in seconds.
- Off-grid builders: cabins, tiny houses, sheds, RVs, vans and boats.
- Real-estate, energy and climate apps, and AI agents that need correct solar numbers for a real place instead of a rule of thumb.

![A chart made by this Actor for a home in Denver using 900 kWh a month: 17 400 W panels (6.8 kW) tilted 34° facing south make 11,008 kWh a year, most in summer and least in December, against the blue line of the monthly use; below, the sunlight on the panels against flat ground](https://api.apify.com/v2/key-value-stores/Km5b4PG3kYHdZSb1E/records/solar-panel-calculator-example.png?signature=1op7zV7npbCkix2A2GimD)

### How to use it

1. Write **Solar systems**, one per entry. The form has examples.
2. Optionally set the **Units** for areas (ft² by default, or m²).
3. Click **Start**. Each system is a row in the results, with its summary, chart and report.

#### What you can write

| You write | It means |
|---|---|
| `in Denver`, `Austin, Texas`, `Sydney, Australia`, `39.74, -104.99` | Where (a town of 5,000+ people or coordinates); the sunlight comes from NASA POWER |
| `900 kWh a month`, `10,800 kWh a year`, `$150 a month bill at 15 cents/kWh` | The electricity use the system should cover |
| `6 kW`, `20 x 400W panels`, `16 panels` | A system size to rate instead of sizing one |
| `30°`, `6/12 roof`, `flat roof`, `facing southwest`, `azimuth 200` | Tilt and facing (the best tilt facing the equator if not given) |
| `roof 400 sq ft`, `80% offset`, `430 W panels`, `12% losses` | Roof room, share of use to cover, panel size (400 W), losses (14%) |
| `$2.80/W`, `$18,000 installed`, `30% tax credit`, `14 cents/kWh` | Cost, incentives and rate for savings and payback |
| `off-grid`, `cabin`, `RV`, `2 kWh a day`, `fridge 60 W 24 h, 2 fans 50 W 6 h` | An off-grid system and its daily load |
| `3 days autonomy`, `lead acid`, `24V`, `summer only`, `peak load 1500 W`, `DC loads` | Battery days, chemistry, voltage, season, inverter size, no inverter |
| `5 sun hours` | Peak sun hours on the panels instead of NASA's data |

The same as an object: `{"lat": 51.5, "lon": -0.13, "panels": 12, "panelWatts": 430, "tilt": 35}`, `{"place": "Tucson, Arizona", "monthlyKwh": [1100, 950, 900, 950, 1200, 1600, 1800, 1750, 1500, 1100, 900, 1050], "costPerWatt": 2.6, "rate": 0.13}` or `{"type": "offgrid", "place": "Duluth, Minnesota", "loads": [{"name": "fridge", "watts": 80, "hours": 24}, {"name": "lights", "watts": 50, "hours": 6}], "battery": "lithium", "autonomyDays": 3}`.

### Examples

- `how big a solar system for 900 kWh a month in Denver` → 6.80 kW (17 × 400 W panels, tilt 34° south, about 476 ft² of roof), 11,008 kWh a year, 1,619 kWh per kW.
- `6 kW system in Austin, Texas facing south, 6/12 roof, $2.80/W, 14 cents/kWh` → 8,689 kWh a year (1,448 kWh per kW), $1,216 a year saved, payback 12.0 years.
- `solar for a $150 a month electric bill in Phoenix at 13 cents per kWh, $18,000 installed` → 8.00 kW (20 panels), 14,244 kWh a year, 103% of the use, payback 9.0 years.
- `off-grid cabin in Flagstaff: fridge 60 W 24 h, lights 40 W 5 h, laptop 60 W 4 h, 2 days autonomy` → 1,880 Wh a day: 2 × 400 W panels, a 4.5 kWh LiFePO4 bank (189 Ah at 24 V), a 50 A MPPT controller, a 300 W inverter.
- `RV using 2 kWh a day, 12V lithium, summer only, in Bozeman, Montana` → 2 × 400 W panels sized for April, 4.8 kWh (403 Ah at 12 V), a 100 A controller.
- `12 x 430W panels in London, tilt 35°` → 5.16 kW, 5,120 kWh a year (992 kWh per kW).

### How-to examples

Each example is a complete input; the results are from runs of the Actor (also listed under **Examples**).

#### How to calculate what size solar system you need

```json
{"requests": ["how big a solar system for 900 kWh a month in Denver"]}
```

Result: 6.80 kW (17 × 400 W panels, tilt 34° south, about 476 ft² of roof), 11,008 kWh a year, 1,619 kWh per kW, with production for every month.

#### How to work out solar panel payback

```json
{"requests": ["6 kW system in Austin, Texas facing south, 6/12 roof, $2.80/W, 14 cents/kWh"]}
```

Result: 8,689 kWh a year (1,448 kWh per kW), $1,216 a year saved, and a payback of 12.0 years. A monthly bill works too: "solar for a $150 a month electric bill in Phoenix at 13 cents per kWh, $18,000 installed" gives 8.00 kW (20 panels), 103% of the use and a 9.0-year payback.

#### How to size an off-grid solar system and battery bank

```json
{"requests": ["off-grid cabin in Flagstaff: fridge 60 W 24 h, lights 40 W 5 h, laptop 60 W 4 h, 2 days autonomy"]}
```

Result: 1,880 Wh a day, met by 2 × 400 W panels, a 4.5 kWh LiFePO4 bank (189 Ah at 24 V), a 50 A MPPT controller and a 300 W inverter. RVs, vans and boats work the same way.

#### How to let an AI agent give real solar numbers

Add this Actor to the [Apify MCP server](https://mcp.apify.com) with `https://mcp.apify.com/?tools=jumblemog/solar-panel-calculator`. The agent passes the user's question as written and answers with numbers for the real place, from NASA sunlight data, instead of a rule of thumb.

### FAQ

**Where does the sunlight data come from?** From 25 years of NASA POWER satellite sunlight and temperature data for the place.

**Does it take my roof angle and direction into account?** Yes. Give a tilt or a roof pitch (`6/12`) and a facing, and it also says what the best tilt for the place would give.

**Can it work from my electricity bill?** Yes: a monthly bill and your rate, yearly or monthly kWh, or a share such as `80% offset`.

**Does it work outside the US?** Yes, anywhere NASA has data, which is the whole world. Set `units` to `metric` for areas in m².

**Is this a quote?** No. It's an estimate to check a quote against: real output depends on shading, equipment and local rules.

### Input

| Field | What it is |
|---|---|
| `requests` | The systems, as lines of text or objects (up to 200 per run) |
| `units` | For areas: `us` (ft²) or `metric` (m²) |
| `charts` | Draw a chart for each system (default on) |

### Output

One dataset item per system, also saved together in the run's `OUTPUT` record:

```json
{
  "request": 1, "status": "ok", "type": "system", "title": "6.8 kW solar system in Denver",
  "summary": "A 6.80 kW system (17 × 400 W panels, tilt 34°, facing south, about 476 ft² of roof) makes 11,008 kWh a year (1,619 kWh per kW), 102% of the 10,800 kWh used.",
  "system": {"kw": 6.8, "panels": 17, "panelWatts": 400, "annualProduction": 11008, "specificYield": 1619,
             "capacityFactor": 18.5, "averageDaily": 30.2, "panelArea": 357, "roofAreaNeeded": 476, "losses": 14,
             "inverterKw": 5.7, "annualUse": 10800, "offset": 102},
  "orientation": {"tilt": 34, "azimuth": 180, "facing": "south", "bestTilt": 34, "shareOfBest": 100},
  "monthly": [{"month": "Jan", "sunOnPanels": 4.27, "production": 766, "sunHorizontal": 2.59, "airTemp": -1.7,
               "cellTemp": 16.7, "use": 917, "net": -152}, "..."],
  "place": {"name": "Denver", "country": "US", "latitude": 39.7392, "longitude": -104.9847, "elevation": 2095},
  "imageUrl": "https://api.apify.com/v2/key-value-stores/.../records/001-6-8-kW-solar-system-in-Denver.png"
}
```

Off-grid items have `offgrid` (dailyLoad, designMonth, arrayWatts, panels, batteryKwh, batteryAh, batteryVoltage, batteryBank, autonomyDays, chargeController, inverterWatts) and `loads` instead of `system`; items with a rate or cost have `money`. Every item also has `units`, `warnings`, `notes` (the method and every assumed value), a Markdown `report` and links to the chart and report. A request that can't be computed has `"status": "failed"` and the reason in `error`, and isn't billed.

### How it works

1. **Sunlight and temperature**: NASA POWER's monthly climatology for the point (satellite and reanalysis data from 2001 on): global and diffuse sunlight on flat ground and the air temperature.
2. **Sunlight on the panels**: the Liu-Jordan isotropic-sky model: beam sunlight scaled by the ratio of the panel's to the ground's beam over each month's average day (integrated every 5 minutes with the NOAA sun position), plus sky diffuse and 20% ground reflection. Any tilt and facing.
3. **Energy**: kWh per kW = sunlight on the panels × (1 − 0.37%/°C above 25 °C at the month's cell temperature) × (1 − 14% losses) × 96% inverter, as NREL's PVWatts does. For Denver it comes within about 3% of PVWatts.
4. **Grid-tied sizing**: the yearly use × offset ÷ kWh per kW, rounded up to whole panels. Payback adds yearly savings with 0.5%/yr panel degradation and 3%/yr electricity price rise until they meet the net cost.
5. **Off-grid sizing**: battery kWh = daily load ÷ inverter efficiency × autonomy days ÷ usable depth (90% lithium, 50% lead-acid); array = the energy into the battery (after its round-trip losses) ÷ kWh per kW per day in the darkest month used, at the tilt that's best for that month; charge controller = array watts ÷ battery volts × 1.25; inverter = all listed loads at once + 25%.

### Pricing

You pay one low price per system, at the price shown on this page. The chart and report are included. Requests that can't be computed are never charged. If you set a maximum cost per run, the Actor stops before a request that wouldn't fit.

### Speed

A system takes about a second (the NASA data for a place is fetched once per run). A run through the API answers in about 10-15 seconds, including the cloud container starting.

### Tips and limits

- **Shade isn't included**: trees, chimneys and neighbouring buildings can cut production a lot; use the `losses` to allow for it.
- **Average years**: a single year can be 5-10% sunnier or cloudier than the climatology.
- **Money**: no maintenance, inverter replacement or net-metering rules; savings count only the energy you use. Check what your utility pays for surplus.
- **Off-grid**: the array is sized to cover the darkest month without a generator; with a generator for the darkest weeks it can be much smaller. Motors draw a surge several times their rating, so check the inverter's surge rating.
- **Limits**: 200 systems per run; places need NASA POWER to answer, or give `sun hours`.

### For AI agents and developers

This Actor works with the [Apify MCP server](https://mcp.apify.com), so AI agents can call it as a tool. Pass `requests` as plain text and read `summary`, `system` or `offgrid`, `monthly`, `money` and `warnings`. A direct API call that waits for the answer:

```bash
curl -X POST "https://api.apify.com/v2/acts/jumblemog~solar-panel-calculator/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"requests": ["how many solar panels for 12,000 kWh a year in Sacramento, California"]}'
```

`run-sync` instead returns the run's `OUTPUT`: the status, the counts and every result as JSON.

In Python, with the `apify-client` package:

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_TOKEN")
run = client.actor("jumblemog/solar-panel-calculator").call(run_input={
    "requests": [{"type": "offgrid", "place": "Duluth, Minnesota", "dailyKwh": 3, "autonomyDays": 3}],
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["summary"])
```

### Credits

- Sunlight and temperature: [NASA POWER](https://power.larc.nasa.gov) (NASA Langley Research Center POWER Project, funded through the NASA Earth Science Directorate Applied Science Program; public).
- Places: [GeoNames](https://www.geonames.org) via [geonamescache](https://github.com/yaph/geonamescache) (CC BY 4.0, MIT).
- Math: [NumPy](https://numpy.org) (BSD-3-Clause). Charts: [Vega-Lite](https://vega.github.io/vega-lite/) and [vl-convert](https://github.com/vega/vl-convert) (BSD-3-Clause), with the [Inter](https://rsms.me/inter/) font (SIL Open Font License).
- Methods: Liu and Jordan; Duffie and Beckman, *Solar Engineering of Thermal Processes*; NREL PVWatts loss assumptions.

# Actor input Schema

## `requests` (type: `array`):

One system per entry, as a line of text or an object. Say where (a town or city of 5,000+ people, with the US state or country if needed: 'Portland, Maine', or coordinates: '39.74, -104.99'); the sunlight and temperature come from NASA POWER, or give 'peak sun hours'. Grid-tied: the use ('900 kWh a month', '10,800 kWh a year'), the bill ('$150 a month at 15 cents/kWh') or the size ('6 kW', '20 x 400W panels'); optional tilt ('30°', '6/12 roof', 'flat roof'), facing ('facing southwest', 'azimuth 200'), 'roof 400 sq ft', '80% offset', cost ('$2.80/W', '$18,000 installed'), '30% tax credit', '12% losses'. Off-grid: the daily load ('2 kWh a day') or the loads with watts and hours ('fridge 60 W 24 h, lights 40 W 5 h, 2 fans 50 W 6 h'), and optionally days of autonomy (2 by default), lithium or lead acid, 12/24/48 V, 'summer only', 'peak load 1500 W', 'DC loads'. Object fields: type (system or offgrid), place, lat, lon, kw, panels, panelWatts, annualKwh, monthlyKwh (a number or 12), monthlyBill, rate, offset, roofArea, costPerWatt, totalCost, incentive, dailyKwh, dailyWh, loads \[{name, watts, hours, quantity}], autonomyDays, battery, voltage, season, months, dcLoads, peakWatts, tilt, azimuth, sunHours, losses, albedo, units, title, text.

## `units` (type: `string`):

For roof and panel areas. Energy is always in kWh, power in W and kW.

## `charts` (type: `boolean`):

Energy by month against the use or load, and the sunlight on the panels.

## Actor input object example

```json
{
  "requests": [
    "how big a solar system for 900 kWh a month in Denver",
    "6 kW system in Austin, Texas facing south, 6/12 roof, $2.80/W, 14 cents/kWh",
    "off-grid cabin in Flagstaff: fridge 60 W 24 h, lights 40 W 5 h, laptop 60 W 4 h, 2 days autonomy",
    "solar for a $150 a month electric bill in Phoenix at 13 cents per kWh, $18,000 installed",
    "RV using 2 kWh a day, 12V lithium, summer only, in Bozeman, Montana",
    {
      "lat": 51.5,
      "lon": -0.13,
      "panels": 12,
      "panelWatts": 430,
      "tilt": 35,
      "azimuth": 180
    }
  ],
  "units": "us",
  "charts": true
}
```

# Actor output Schema

## `results` (type: `string`):

One row per request: the summary and chart.

## `output` (type: `string`):

The OUTPUT record: every result in one JSON object.

## `files` (type: `string`):

Charts (PNG and SVG) and Markdown reports in the run's key-value store.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "requests": [
        "how big a solar system for 900 kWh a month in Denver",
        "6 kW system in Austin, Texas facing south, 6/12 roof, $2.80/W, 14 cents/kWh",
        "off-grid cabin in Flagstaff: fridge 60 W 24 h, lights 40 W 5 h, laptop 60 W 4 h, 2 days autonomy",
        "solar for a $150 a month electric bill in Phoenix at 13 cents per kWh, $18,000 installed",
        "RV using 2 kWh a day, 12V lithium, summer only, in Bozeman, Montana",
        {
            "lat": 51.5,
            "lon": -0.13,
            "panels": 12,
            "panelWatts": 430,
            "tilt": 35,
            "azimuth": 180
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("jumblemog/solar-panel-calculator").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "requests": [
        "how big a solar system for 900 kWh a month in Denver",
        "6 kW system in Austin, Texas facing south, 6/12 roof, $2.80/W, 14 cents/kWh",
        "off-grid cabin in Flagstaff: fridge 60 W 24 h, lights 40 W 5 h, laptop 60 W 4 h, 2 days autonomy",
        "solar for a $150 a month electric bill in Phoenix at 13 cents per kWh, $18,000 installed",
        "RV using 2 kWh a day, 12V lithium, summer only, in Bozeman, Montana",
        {
            "lat": 51.5,
            "lon": -0.13,
            "panels": 12,
            "panelWatts": 430,
            "tilt": 35,
            "azimuth": 180,
        },
    ] }

# Run the Actor and wait for it to finish
run = client.actor("jumblemog/solar-panel-calculator").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "requests": [
    "how big a solar system for 900 kWh a month in Denver",
    "6 kW system in Austin, Texas facing south, 6/12 roof, $2.80/W, 14 cents/kWh",
    "off-grid cabin in Flagstaff: fridge 60 W 24 h, lights 40 W 5 h, laptop 60 W 4 h, 2 days autonomy",
    "solar for a $150 a month electric bill in Phoenix at 13 cents per kWh, $18,000 installed",
    "RV using 2 kWh a day, 12V lithium, summer only, in Bozeman, Montana",
    {
      "lat": 51.5,
      "lon": -0.13,
      "panels": 12,
      "panelWatts": 430,
      "tilt": 35,
      "azimuth": 180
    }
  ]
}' |
apify call jumblemog/solar-panel-calculator --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,jumblemog/solar-panel-calculator"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/YBlw2NeflBrGxno5D/builds/zO5FPRkEAjElP15iV/openapi.json
