# HVAC Load Calculator: Heating, Cooling, AC Tons, Furnace Size (`jumblemog/hvac-load-calculator`) Actor

Heating and cooling loads from a plain-text house or room description: Manual J-style heat balance with window solar gains, component breakdown, and air conditioner, mini-split and furnace sizes.

- **URL**: https://apify.com/jumblemog/hvac-load-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

## HVAC Load Calculator: Heating, Cooling, AC Tons, Furnace Size

**Heating and cooling loads for a house or a room from one line of text.** Describe it the way you would to a contractor (`2000 sq ft house, 2 stories, R-13 walls, R-38 attic, double-pane windows, climate zone 5` or `room 12 x 14 ft, 2 exterior walls facing south and west, 40 sq ft window on the west, zone 3`) and you get back:

- **The heating load** in Btu/h and kW at the winter design temperature.
- **The cooling load** at the hottest hour of the design day, split into sensible and latent (moisture) heat, in Btu/h, kW and tons.
- **Equipment sizes**: the standard air conditioner size in tons, the mini-split or window unit size for small spaces, the furnace input at its efficiency (AFUE), the electric heat in kW, the sensible heat ratio and square feet per ton.
- **Where the heat goes**: heating and cooling by walls, ceiling, floor, windows, window sun, doors, air leakage, ventilation, people, appliances and ducts, with each one's share.
- **Every assumption**: anything you leave out (window type, insulation, air tightness, duct location, occupants) gets a usual value, and each one is listed so you can correct it.
- **A chart**: the loads by component and the cooling load through the design day.

It's made for:

- Homeowners checking whether a contractor's 4-ton quote fits a 2,000 ft² house, or what mini-split a bedroom, garage conversion or addition needs.
- HVAC contractors and salespeople getting a quick load before a full Manual J, and comparing upgrades (attic insulation, windows, air sealing).
- Energy auditors, architects and students who want to see which parts of a house drive its loads, and AI agents that need defensible heating and cooling numbers instead of a 500-ft²-per-ton rule of thumb.

![A load calculation made by this Actor for a 2,000 ft² two-story house in climate zone 5: heating by component (windows, infiltration and walls largest, 41,609 Btu/h in all), cooling by component with window solar gain the largest part (29,235 Btu/h), and the sensible cooling load through the design day peaking at 3 pm](https://api.apify.com/v2/key-value-stores/Km5b4PG3kYHdZSb1E/records/hvac-load-calculator-example.png?signature=13znSTzHOYztcqCwVXnoZ)

### How to use it

1. Write **Houses and rooms**, one per entry. The form has examples.
2. Optionally set the **Climate zone** for requests that don't name one, and the **Units** for numbers without one (US by default).
3. Click **Start**. Each request is a row in the results, with its summary, chart and report.

#### What you can write

| You write | It means |
|---|---|
| `2000 sq ft house`, `120 m2 apartment`, `room 12 x 14 ft`, `4 x 3.5 m` | The floor area, or a room's length and width |
| `2 stories`, `ranch`, `9 ft ceilings`, `2.5 m ceilings` | Stories and ceiling height (8 ft if not given) |
| `climate zone 5`, `zone 2B`, `cz 4C` | The US IECC climate zone (A moist, B dry, C marine) for the design conditions |
| `10°F winter, 95°F summer`, `-5°C winter, 32°C summer`, `indoor 68/76` | Outdoor design temperatures, and indoor setpoints (70/75 °F if not given) |
| `humid`, `dry` | Outdoor moisture, for the latent load |
| `R-13 walls`, `R-38 attic`, `R-19 floor`, `uninsulated` | Insulation R-values (RSI also read) |
| `slab`, `insulated slab`, `crawlspace`, `over a basement`, `over a garage` | The floor |
| `cathedral ceiling`, `flat roof`, `apartment above`, `dark roof` | The ceiling or roof |
| `single-pane`, `double-pane`, `low-e`, `triple pane`, `U 0.3`, `SHGC 0.25` | The windows |
| `200 sq ft of windows`, `15% windows`, `40 sq ft window on the west`, `blinds` | Window area, orientation and shading |
| `2 exterior walls facing south and west`, `3 exterior walls`, `2 doors` | A room's outside walls, and doors |
| `tight`, `average`, `leaky`, `3 ACH50`, `0.4 ach` | Air leakage |
| `HRV`, `ERV`, `60 cfm ventilation`, `mechanical ventilation` | Ventilation air (ASHRAE 62.2 rate if no number) and heat recovery |
| `ducts in the attic`, `ductless`, `ducts in the basement` | Duct losses |
| `3 bedrooms`, `4 people`, `500 W of computers`, `80% AFUE` | Occupants, extra heat gains, furnace efficiency |

The same as an object: `{"floorArea": 1800, "climateZone": "6A", "wallR": 21, "ceilingR": 49, "windowType": "lowe", "ach50": 3, "ventilation": true, "recovery": "hrv", "floorType": "basement", "ducts": "conditioned"}` or `{"type": "room", "length": "4 m", "width": "3.5 m", "exteriorWalls": 2, "wallOrientations": ["S", "E"], "windows": [{"area": "3 m2", "orientation": "S"}], "climateZone": "4C"}`.

### Examples

- `2000 sq ft house, 2 stories, 8 ft ceilings, R-13 walls, R-38 attic, double-pane windows, climate zone 5` → heating 41,609 Btu/h (12.2 kW); cooling 29,235 Btu/h (2.44 tons, peak 2-3 pm); a 2.5-ton air conditioner and a 60,000 Btu/h furnace; 821 ft² per ton.
- `room 12 x 14 ft, 8 ft ceiling, 2 exterior walls facing south and west, 40 sq ft window on the west, R-13 walls, zone 3, R-30 attic` → cooling 7,148 Btu/h peaking at 4-5 pm (the west window is two thirds of it); a 9,000 Btu/h mini-split; heating 2,388 Btu/h.
- `1500 sq ft ranch in climate zone 2B, slab, R-19 attic, 200 sq ft of windows, leaky, ducts in the attic` → cooling 32,099 Btu/h, a 3-ton air conditioner; heating 27,449 Btu/h.
- `3000 sq ft two story home, humid, 98°F summer, 30°F winter, low-e windows, ducts in attic` → cooling 40,324 Btu/h with 5,481 Btu/h latent, a 3.5-ton air conditioner.
- The tight zone 6A house object above → heating 29,221 Btu/h, cooling 1.34 tons (1,348 ft² per ton).

### How-to examples

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

#### How to calculate the heating and cooling load of a house

```json
{"requests": ["2000 sq ft house, 2 stories, 8 ft ceilings, R-13 walls, R-38 attic, double-pane windows, climate zone 5"]}
```

Result: heating 41,609 Btu/h (12.2 kW) and cooling 29,235 Btu/h (2.44 tons, peak at 2-3 pm), so a 2.5-ton air conditioner and a 60,000 Btu/h furnace, at 821 ft² per ton.

#### How to size a mini-split for one room

```json
{"requests": ["room 12 x 14 ft, 8 ft ceiling, 2 exterior walls facing south and west, 40 sq ft window on the west, R-13 walls, zone 3, R-30 attic"]}
```

Result: cooling 7,148 Btu/h peaking at 4-5 pm, two thirds of it from the west window, so a 9,000 Btu/h mini-split; heating 2,388 Btu/h.

#### How to find what size air conditioner a home needs

```json
{"requests": ["1500 sq ft ranch in climate zone 2B, slab, R-19 attic, 200 sq ft of windows, leaky, ducts in the attic"]}
```

Result: cooling 32,099 Btu/h, a 3-ton air conditioner, and heating 27,449 Btu/h. Summer and winter design temperatures, humidity and window types can be given in the line too.

#### How to let an AI agent estimate HVAC loads

Add this Actor to the [Apify MCP server](https://mcp.apify.com) with `https://mcp.apify.com/?tools=jumblemog/hvac-load-calculator`. The agent describes the house as the owner did and answers with the load and the equipment size, worked out room by room from walls, windows and climate, instead of a square-foot rule.

### FAQ

**Is this a Manual J?** It's a simplified method in the spirit of ACCA Manual J, good for planning, checking quotes and comparing upgrades. Code compliance and final equipment selection need a full Manual J.

**What do I need to know about the house?** The floor area and a climate zone or design temperatures at least. Insulation, windows, air leakage and ducts improve the estimate.

**Does it include latent (humidity) load?** Yes, for humid climates.

**Can I compare upgrades?** Yes. Run the same house with better attic insulation or windows and compare the loads.

**Does it work with Zapier, Make or n8n?** Yes. Call the Actor with its Apify app or an HTTP request and pass the summary on.

### Input

| Field | What it is |
|---|---|
| `requests` | The houses and rooms, as lines of text or objects (up to 200 per run) |
| `climateZone` | The climate zone for requests that don't give one or their design temperatures (4A when empty) |
| `units` | For numbers without a unit: `us` (ft, ft², °F) or `metric` (m, m², °C) |
| `charts` | Draw a chart for each request (default on) |

### Output

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

```json
{
  "request": 1, "status": "ok", "type": "house", "title": "House, 2,000 ft², zone 5A",
  "summary": "Heating 41,609 Btu/h (12.2 kW); cooling 29,235 Btu/h (2.44 tons: 27,328 sensible, 1,907 latent, peak 14:00-15:00); a 2.5 ton air conditioner and a 60,000 Btu/h (95% AFUE) furnace; 821 ft² per ton.",
  "loads": {"heating": 41609, "heatingWatts": 12194, "coolingTotal": 29235, "coolingSensible": 27328, "coolingLatent": 1907,
            "coolingWatts": 8568, "coolingTons": 2.44, "peakHour": "14:00-15:00 solar time",
            "heatingPerFloorArea": 20.8, "coolingPerFloorArea": 14.6},
  "equipment": {"nominalAirConditioner": "2.5 ton", "nominalMiniSplit": 30000, "sensibleHeatRatio": 0.935,
                "squareFeetPerTon": 820.9, "furnaceOutput": 41609, "nominalFurnaceInput": 60000, "afue": 0.95, "electricHeatKw": 12.2},
  "climate": {"climateZone": "5A", "outdoorHeating": 2, "indoorHeating": 70, "outdoorCooling": 90, "indoorCooling": 75,
              "moistureDifference": 15, "dailyRange": 22, "latitude": 41},
  "components": [{"component": "Walls", "heating": 8757, "coolingSensible": 3219, "coolingLatent": 0, "heatingShare": 0.21, "coolingShare": 0.11}, "..."],
  "building": {"floorArea": 2000, "wallArea": 2066, "windowArea": 300, "wallU": 0.0746, "ceilingU": 0.0262, "...": "..."},
  "imageUrl": "https://api.apify.com/v2/key-value-stores/.../records/001-House-2-000-ft-zone-5A.png"
}
```

Every item also has `data` (the outdoor temperature and sensible cooling load for each hour of the design day), `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. **Conduction**: U·A·ΔT through each wall, the ceiling or roof, windows and doors. U-factors come from the R-values with framing, air films and finishes (R-13 wall → U 0.074, R-30 ceiling → 0.033); slab floors lose heat at the edge (F-factor 0.73 Btu/h·ft·°F, 0.54 insulated); floors over crawlspaces, basements and garages see part of the temperature difference.
2. **Cooling day**: the outdoor temperature follows the ASHRAE daily profile below the design high; walls and roofs add a sol-air allowance for the sun on them; window solar gain is area × SHGC × shading × the sunlight on each window, computed every hour from a clear-sky sun on the 21st of July at the zone's latitude. The cooling load is the worst hour.
3. **Air**: infiltration and ventilation at 1.08·CFM·ΔT (sensible) and 0.68·CFM·Δgrains (latent), with air changes per hour by tightness (or from ACH50), and HRV or ERV recovery.
4. **Internal gains and ducts**: 230 Btu/h sensible and 200 latent per person (bedrooms + 1), 1,600 Btu/h of appliances in a house (300 in a room), and duct losses by location (attic 15% heating, 25% cooling).
5. **Equipment**: the smallest standard air conditioner at or above 95% of the total load (Manual S allows up to 115%), mini-splits from 6,000 Btu/h, and a furnace whose input times its AFUE covers the heating load.

### Pricing

You pay one low price per house or room, 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

Each house or room takes a few milliseconds. A run through the API answers in about 10 seconds, including the cloud container starting.

### Tips and limits

- **An estimate, not a permit document**: this is a simplified method in the spirit of ACCA Manual J, good for planning, checking quotes and comparing upgrades. Code compliance and final equipment selection need a full Manual J with the house's real dimensions by a designer.
- **Design temperatures**: climate zone values are representative; your local ASHRAE design temperatures can differ by 10 °F or more, so give them (`8°F winter, 93°F summer`) when you know them.
- **Shape**: without a length and width, a house is taken as a 1.5:1 rectangle with windows spread around it in proportion to the walls; give the windows by direction for a better cooling number.
- **Sun**: window gains use a clear sky with no overhangs unless you say `overhangs` or `blinds`; trees and neighbouring buildings aren't modelled.
- **Oversizing**: a bigger air conditioner than the load short-cycles and removes less moisture; the sensible heat ratio and square feet per ton help spot a quote that's too big.
- **Limits**: 200 requests per run; 20 to 100,000 ft²; up to 5 stories.

### 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`, `loads`, `equipment`, `components` and `warnings`. A direct API call that waits for the answer:

```bash
curl -X POST "https://api.apify.com/v2/acts/jumblemog~hvac-load-calculator/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"requests": ["2400 sq ft two story house, R-19 walls, R-49 attic, low-e windows, tight, climate zone 5"]}'
```

`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/hvac-load-calculator").call(run_input={
    "requests": [{"type": "room", "length": 20, "width": 20, "exteriorWalls": 3, "wallR": 0,
                  "windows": [{"area": 30, "orientation": "W"}], "climateZone": "3A"}],
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["summary"])
```

### Credits

- 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: the heat balance and air formulas of the ASHRAE Handbook of Fundamentals residential load method and ACCA Manual J (concepts, not their tables); sun position by the NOAA solar calculator equations (Meeus); clear-sky beam by Meinel; ASHRAE 62.2 ventilation rate; US IECC climate zones.

# Actor input Schema

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

One house or room per entry, as a line of text or an object. Size: the floor area ('2000 sq ft', '120 m2') or the room's dimensions ('12 x 14 ft'), stories, ceiling height. Climate: the IECC climate zone ('climate zone 5', '2B') or the outdoor design temperatures ('10°F winter, 95°F summer'); 'humid' or 'dry'. Envelope: 'R-13 walls', 'R-38 attic', 'cathedral ceiling', 'apartment above', 'slab', 'crawlspace', 'over a garage', windows ('double-pane', 'low-e', 'single-pane', '200 sq ft of windows', '40 sq ft window on the west', '15% windows'), 'blinds', doors. Rooms: '2 exterior walls facing south and west'. Air: 'tight', 'average', 'leaky', '3 ACH50', 'HRV', '60 cfm ventilation'. Ducts: 'ducts in the attic', 'ductless'. People: '3 bedrooms', '4 people', '500 W of computers'. Anything left out is assumed and listed in notes. Object fields: type (house or room), floorArea, length, width, stories, ceilingHeight, exteriorWalls, wallOrientations, wallR, ceilingR, floorR, floorType, slabInsulated, ceiling, windowArea, windows \[{area, orientation, u, shgc}], windowType, windowU, shgc, shading, doors, tightness, ach, ach50, ventilation, recovery, ducts, climateZone, outdoorHeating, outdoorCooling, indoorHeating, indoorCooling, humidity, grains, dailyRange, latitude, bedrooms, people, appliances, wallColor, roofColor, afue, units, title, text.

## `climateZone` (type: `string`):

For requests without a climate zone or design temperatures (zone 4A when this is empty). US IECC zones: 1 south Florida, 2 Gulf Coast and Phoenix (2B), 3 the South and coastal California (3C), 4 the mid-Atlantic and Pacific Northwest (4C), 5 the Midwest and Northeast, 6 the northern states, 7 northern Minnesota, 8 Alaska.

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

For sizes and temperatures written without a unit. m², m or °C in a request switch it to metric.

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

The heating and cooling loads by component and the cooling load through the design day.

## Actor input object example

```json
{
  "requests": [
    "2000 sq ft house, 2 stories, 8 ft ceilings, R-13 walls, R-38 attic, double-pane windows, climate zone 5",
    "room 12 x 14 ft, 8 ft ceiling, 2 exterior walls facing south and west, 40 sq ft window on the west, R-13 walls, zone 3, R-30 attic",
    "1500 sq ft ranch in climate zone 2B, slab, R-19 attic, 200 sq ft of windows, leaky, ducts in the attic",
    "3000 sq ft two story home, humid, 98°F summer, 30°F winter, low-e windows, ducts in attic",
    "120 m2 apartment, 2.5 m ceilings, -5°C winter, 32°C summer, apartment above, triple pane",
    {
      "floorArea": 1800,
      "climateZone": "6A",
      "wallR": 21,
      "ceilingR": 49,
      "windowType": "lowe",
      "ach50": 3,
      "ventilation": true,
      "recovery": "hrv",
      "floorType": "basement",
      "ducts": "conditioned"
    }
  ],
  "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": [
        "2000 sq ft house, 2 stories, 8 ft ceilings, R-13 walls, R-38 attic, double-pane windows, climate zone 5",
        "room 12 x 14 ft, 8 ft ceiling, 2 exterior walls facing south and west, 40 sq ft window on the west, R-13 walls, zone 3, R-30 attic",
        "1500 sq ft ranch in climate zone 2B, slab, R-19 attic, 200 sq ft of windows, leaky, ducts in the attic",
        "3000 sq ft two story home, humid, 98°F summer, 30°F winter, low-e windows, ducts in attic",
        "120 m2 apartment, 2.5 m ceilings, -5°C winter, 32°C summer, apartment above, triple pane",
        {
            "floorArea": 1800,
            "climateZone": "6A",
            "wallR": 21,
            "ceilingR": 49,
            "windowType": "lowe",
            "ach50": 3,
            "ventilation": true,
            "recovery": "hrv",
            "floorType": "basement",
            "ducts": "conditioned"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("jumblemog/hvac-load-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": [
        "2000 sq ft house, 2 stories, 8 ft ceilings, R-13 walls, R-38 attic, double-pane windows, climate zone 5",
        "room 12 x 14 ft, 8 ft ceiling, 2 exterior walls facing south and west, 40 sq ft window on the west, R-13 walls, zone 3, R-30 attic",
        "1500 sq ft ranch in climate zone 2B, slab, R-19 attic, 200 sq ft of windows, leaky, ducts in the attic",
        "3000 sq ft two story home, humid, 98°F summer, 30°F winter, low-e windows, ducts in attic",
        "120 m2 apartment, 2.5 m ceilings, -5°C winter, 32°C summer, apartment above, triple pane",
        {
            "floorArea": 1800,
            "climateZone": "6A",
            "wallR": 21,
            "ceilingR": 49,
            "windowType": "lowe",
            "ach50": 3,
            "ventilation": True,
            "recovery": "hrv",
            "floorType": "basement",
            "ducts": "conditioned",
        },
    ] }

# Run the Actor and wait for it to finish
run = client.actor("jumblemog/hvac-load-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": [
    "2000 sq ft house, 2 stories, 8 ft ceilings, R-13 walls, R-38 attic, double-pane windows, climate zone 5",
    "room 12 x 14 ft, 8 ft ceiling, 2 exterior walls facing south and west, 40 sq ft window on the west, R-13 walls, zone 3, R-30 attic",
    "1500 sq ft ranch in climate zone 2B, slab, R-19 attic, 200 sq ft of windows, leaky, ducts in the attic",
    "3000 sq ft two story home, humid, 98°F summer, 30°F winter, low-e windows, ducts in attic",
    "120 m2 apartment, 2.5 m ceilings, -5°C winter, 32°C summer, apartment above, triple pane",
    {
      "floorArea": 1800,
      "climateZone": "6A",
      "wallR": 21,
      "ceilingR": 49,
      "windowType": "lowe",
      "ach50": 3,
      "ventilation": true,
      "recovery": "hrv",
      "floorType": "basement",
      "ducts": "conditioned"
    }
  ]
}' |
apify call jumblemog/hvac-load-calculator --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,jumblemog/hvac-load-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/Ebr7l4FnnNcuiUc1u/builds/hp6SsIq7JPHe4i9Nx/openapi.json