# HVAC Superheat & Subcooling Calculator (Refrigerant Charge) (`jumblemog/refrigerant-charge-calculator`) Actor

Refrigerant charge checks from plain text: superheat and subcooling from gauge readings with the piston or TXV target and an add, recover, restriction or airflow verdict, target superheat, pressure-temperature charts for 15 refrigerants including R-410A, R-454B and R-32, and line set charge.

- **URL**: https://apify.com/jumblemog/refrigerant-charge-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 Superheat & Subcooling Calculator (Refrigerant Charge)

**Check an air conditioner's or heat pump's refrigerant charge, look up refrigerant pressure-temperature values, or work out the extra charge for a long line set, from one line of text.** Ask `R-410A piston, suction 118 psig, suction line 60 F, liquid 340 psig, liquid line 98 F, 63 wet bulb, 85 outdoor` or `R-454B at 120 psig` and you get back:

- **Superheat and subcooling** from your gauge pressures and line temperatures, with the evaporator and condensing saturation temperatures (dew point for superheat and bubble point for subcooling on blends with glide, such as R-454B and R-407C).
- **The target**: fixed-orifice (piston, capillary) target superheat from the indoor wet bulb and outdoor temperature, or TXV/EEV target subcooling.
- **A verdict**: charge OK, undercharged (add), overcharged (recover), a likely restriction or an airflow problem, with the condenser approach, evaporator TD and temperature split when you give the air temperatures.
- **Pressure-temperature (PT) lookups and charts** for 15 refrigerants: R-410A, R-454B, R-32, R-22, R-452B, R-513A, R-134a, R-407C, R-404A, R-507A, R-1234yf, R-290, R-600a, R-744 (CO2) and R-717 (ammonia).
- **Line set charge**: how much refrigerant to add for line set beyond what the factory charge covers, by liquid line size.
- **Charts** (superheat and subcooling gauges, target superheat curves, the PT curve) and a **Markdown report**.

It's made for:

- HVAC technicians and apprentices checking a charge or a PT value on the job.
- Contractors, trainers and students learning to read gauges and diagnose a system.
- AI agents, service apps and field tools that need charging numbers they can show their work for.

![A chart made by this Actor for an R-410A system with a piston: superheat 20.2 °F against a 7-17 °F target range and subcooling 6.6 °F against 7-13 °F, both out of range, with the readings: 118 psig suction at 39.8 °F, 340 psig liquid at 104.6 °F, 63 °F wet bulb, 85 °F outdoor and a 19.6 °F condenser approach](https://api.apify.com/v2/key-value-stores/Km5b4PG3kYHdZSb1E/records/refrigerant-charge-calculator-example.png?signature=137wLM3tzEem4m8lW3L4R)

### How to use it

1. Write **Requests**, one per entry. The form has examples.
2. Optionally set a **Default refrigerant** and **Default metering device**.
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 |
|---|---|
| `R-410A`, `R-454B`, `R-22`, `puron`, `puron advance` | The refrigerant |
| `piston`, `fixed orifice`, `cap tube` / `TXV`, `EEV` | The metering device (charge by superheat / by subcooling) |
| `suction 118 psig`, `suction line 60 F` | Suction pressure and suction line temperature (superheat) |
| `liquid 340 psig`, `head pressure 340`, `liquid line 98 F` | Liquid pressure and liquid line temperature (subcooling) |
| `63 wet bulb`, `85 outdoor`, `return 75 F`, `supply 57 F` | Indoor wet bulb, outdoor temperature and the air across the coil |
| `superheat 15 F, subcooling 4 F`, `target subcooling 9` | Readings you already have, or the nameplate target |
| `R-454B at 120 psig`, `R-407C 45 F`, `PT chart for R-32` | A pressure-temperature lookup or a whole chart |
| `R-410A line set 50 ft, 3/8 liquid line, 15 ft included`, `0.6 oz per ft`, `factory charge 6 lb 4 oz` | Line set charge |
| `8.5 bar`, `600 kPa`, `12 C`, `in celsius` | Metric: answers in °C and bar(g) |

The same as an object: `{"refrigerant": "R-22", "metering": "piston", "suctionPressure": "58 psig", "suctionLineTemp": "65 F", "wetBulb": 62, "outdoor": 90}`.

### Examples

- `R-410A piston, suction 118 psig, suction line 60 F, liquid 340 psig, liquid line 98 F, 63 wet bulb, 85 outdoor` → evaporator 39.8 °F, superheat 20.2 °F against a 12 °F target, subcooling 6.6 °F: undercharged, add refrigerant in small steps.
- `R-454B TXV, suction 115 psig, suction line 55 F, liquid 400 psig, liquid line 105 F, target subcooling 9` → evaporator 43.5 °F (dew), condensing 120.5 °F (bubble), subcooling 15.5 °F: overcharged, recover.
- `R-410A piston, superheat 30, subcooling 20, 63 wb, 85 odb` → high superheat with high subcooling: a restriction, not the charge.
- `target superheat, 63 wet bulb, 85 outdoor` → 12 °F.
- `R-407C at 45 F` → 88.8 psig liquid (bubble), 70.7 psig vapor (dew).
- `R-410A line set 50 ft, 3/8 liquid line, 15 ft included` → add 19 oz (1 lb 3 oz) for 35 ft at 0.54 oz per ft.

### How-to examples

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

#### How to check an AC's refrigerant charge with superheat (piston)

```json
{"requests": ["R-410A piston, suction 118 psig, suction line 60 F, liquid 340 psig, liquid line 98 F, 63 wet bulb, 85 outdoor"]}
```

Result: evaporator 39.8 °F, superheat 20.2 °F against a 12 °F target, and subcooling 6.6 °F: undercharged, so add refrigerant in small steps.

#### How to check charge by subcooling on a TXV system

```json
{"requests": ["R-454B TXV, suction 115 psig, suction line 55 F, liquid 400 psig, liquid line 105 F, target subcooling 9"]}
```

Result: evaporator 43.5 °F (dew), condensing 120.5 °F (bubble) and subcooling 15.5 °F: overcharged, so recover some. High superheat with high subcooling is flagged as a likely restriction, not the charge.

#### How to work out the extra charge for a long line set

```json
{"requests": ["R-410A line set 50 ft, 3/8 liquid line, 15 ft included"]}
```

Result: add 19 oz (1 lb 3 oz) for the 35 extra feet, at 0.54 oz per ft.

#### How to let an AI agent help with charging

Add this Actor to the [Apify MCP server](https://mcp.apify.com) with `https://mcp.apify.com/?tools=jumblemog/refrigerant-charge-calculator`. The agent passes the gauge readings in one line and answers with the superheat, subcooling, target and verdict, using the refrigerant's real pressure-temperature data.

### FAQ

**Which refrigerants does it know?** 15: R-410A, R-454B, R-32, R-22, R-452B, R-513A, R-134a, R-407C, R-404A, R-507A, R-1234yf, R-290, R-600a, R-744 (CO2) and R-717 (ammonia).

**Does it handle blends with glide?** Yes. Superheat uses the dew point and subcooling the bubble point.

**Can it give PT chart values?** Yes: `R-407C at 45 F` gives 88.8 psig liquid (bubble) and 70.7 psig vapor (dew).

**Where does the target superheat come from?** For fixed-orifice systems, from the indoor wet bulb and outdoor temperature: `target superheat, 63 wet bulb, 85 outdoor` gives 12 °F. TXV and EEV systems use a target subcooling.

### Input

| Field | What it is |
|---|---|
| `requests` | Charge checks, target superheats, PT lookups or line sets, as lines of text or objects (up to 200 per run) |
| `refrigerant` | Refrigerant when a request doesn't name one |
| `metering` | Fixed orifice or TXV when a request doesn't say |
| `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": "check", "title": "R-410A charge check (fixed orifice)",
  "summary": "R-410A, fixed orifice: superheat 20.2 °F (target 12 °F) and subcooling 6.6 °F (target 10 °F) (evaporator 39.8 °F at 118 psig, condensing 104.6 °F at 340 psig). Undercharged: Add refrigerant in small steps (about 4-8 oz on a 2-5 ton system), run 10-15 minutes and measure again.",
  "readings": {"refrigerant": "R-410A", "suctionPressure": 118, "evaporatorSaturation": 39.8, "suctionLineTemperature": 60,
               "liquidPressure": 340, "condensingSaturation": 104.6, "liquidLineTemperature": 98, "superheat": 20.2, "subcooling": 6.6},
  "targets": {"metering": "fixed orifice", "superheat": 12, "superheatLow": 7, "superheatHigh": 17, "subcooling": 10},
  "diagnosis": {"verdict": "Undercharged", "action": "Add refrigerant in small steps ...", "superheat": "high", "subcooling": "low",
                "condenserApproach": 19.6},
  "units": {"temperature": "°F", "temperatureDifference": "°F", "pressure": "psig", "charge": "oz", "length": "ft"}
}
```

A target has `target` and `table`; a PT request has `refrigerant`, `point`, `critical` and `table`; a line set has `lineset`, `list` and `sizes`. Every item has `warnings`, `notes` (every assumption and default), 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. **Saturation**: [CoolProp](http://www.coolprop.org/) 8 Helmholtz equations of state. R-410A, R-407C, R-404A and R-507A are CoolProp's pseudo-pure blends with their own bubble and dew curves; R-454B, R-452B and R-513A are mixed from their components and their bubble and dew curves traced to the critical point.
2. **Superheat** = suction line temperature − dew point at the suction pressure; **subcooling** = bubble point at the liquid pressure − liquid line temperature. Gauge pressures are against sea-level atmosphere.
3. **Fixed-orifice target superheat** = (3 × indoor wet bulb − 80 − outdoor dry bulb) / 2 °F, the line manufacturers' charging charts follow, ± 5 °F; no value under 5 °F.
4. **TXV/EEV**: charged to the nameplate subcooling (10 °F by default) ± 3 °F; its superheat is only flagged under 3 °F or over 20 °F.
5. **Verdict**: high superheat and low subcooling = undercharged; low superheat and high subcooling = overcharged; both high = restriction; low superheat without high subcooling = low indoor airflow.
6. **Line set**: ACR copper inside volume × saturated liquid density at 95 °F per foot beyond the length the factory charge covers (15 ft unless you say).

### Pricing

You pay one low price per request, at the price shown on this page: a charge check costs a little more than a target superheat, PT lookup or chart, or line set charge. The charts 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 request takes milliseconds. A run through the API answers in about 10 seconds, including the cloud container starting.

### Tips and limits

- **Follow the manufacturer.** The unit's charging chart, nameplate subcooling and line set table come first; this is the check and the arithmetic behind them.
- **Measure right**: run the system 15 minutes with clean filters and the right airflow, and clamp an insulated pipe thermometer near the service valves.
- **Only certified technicians** (EPA Section 608 in the US) may add or recover refrigerant.
- **Limits**: 200 requests per run; saturation up to just below each refrigerant's critical point.

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

```bash
curl -X POST "https://api.apify.com/v2/acts/jumblemog~refrigerant-charge-calculator/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"requests": ["R-410A TXV, suction 120 psig, suction line 52 F, head 380 psig, liquid line 95 F", "R-454B at 40 F"]}'
```

`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/refrigerant-charge-calculator").call(run_input={
    "requests": [{"refrigerant": "R-410A", "metering": "txv", "liquidPressure": "380 psig", "liquidLineTemp": "95 F"}],
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["summary"])
```

### Credits

- Properties: [CoolProp](http://www.coolprop.org/) (MIT License), Bell et al., *Ind. Eng. Chem. Res.* 53 (2014) 2498-2508.
- 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).

# Actor input Schema

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

One request per entry, as a line of text or an object. Charge check: the refrigerant, 'piston' or 'TXV', suction pressure and suction line temperature (superheat), liquid (head) pressure and liquid line temperature (subcooling), and for a piston the indoor wet bulb and outdoor temperature; optional 'target subcooling 9', return and supply air. Or give 'superheat 15 F, subcooling 4 F' directly. Target superheat: '63 wet bulb, 85 outdoor'. PT: 'R-410A at 118 psig', 'R-454B 40 F', 'PT chart for R-32'. Line set: 'R-410A line set 50 ft, 3/8 liquid line, 15 ft included', '0.6 oz per ft', 'factory charge 6 lb 4 oz'. psig and °F, or bar(g)/kPa and °C. Refrigerants: R-410A, R-22, R-32, R-454B, R-452B, R-513A, R-134a, R-407C, R-404A, R-507A, R-1234yf, R-290, R-600a, R-744, R-717. Object fields: type (check, target, pt, lineset), refrigerant, metering, suctionPressure, suctionLineTemp, liquidPressure, liquidLineTemp, wetBulb, outdoor, returnAir, supplyAir, superheat, subcooling, targetSuperheat, targetSubcooling, pressure, temperature, chart, lineSetLength, included, lineSize, ozPerFt, factoryCharge, units (us or metric), title, text.

## `refrigerant` (type: `string`):

Refrigerant when a request doesn't name one (R-410A for charge checks and line sets otherwise).

## `metering` (type: `string`):

How to judge the charge when a request doesn't say: by superheat (fixed orifice) or by subcooling (TXV/EEV).

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

Superheat and subcooling gauges, the target superheat curves, the PT curve or the line charge per size.

## Actor input object example

```json
{
  "requests": [
    "R-410A piston, suction 118 psig, suction line 60 F, liquid 340 psig, liquid line 98 F, 63 wet bulb, 85 outdoor",
    "R-454B TXV, suction 115 psig, suction line 55 F, liquid 400 psig, liquid line 105 F, target subcooling 9",
    "target superheat, 63 wet bulb, 85 outdoor",
    "R-407C at 45 F",
    "PT chart for R-32",
    "R-410A line set 50 ft, 3/8 liquid line, 15 ft included",
    {
      "refrigerant": "R-22",
      "metering": "piston",
      "suctionPressure": "58 psig",
      "suctionLineTemp": "65 F",
      "wetBulb": 62,
      "outdoor": 90
    }
  ],
  "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": [
        "R-410A piston, suction 118 psig, suction line 60 F, liquid 340 psig, liquid line 98 F, 63 wet bulb, 85 outdoor",
        "R-454B TXV, suction 115 psig, suction line 55 F, liquid 400 psig, liquid line 105 F, target subcooling 9",
        "target superheat, 63 wet bulb, 85 outdoor",
        "R-407C at 45 F",
        "PT chart for R-32",
        "R-410A line set 50 ft, 3/8 liquid line, 15 ft included",
        {
            "refrigerant": "R-22",
            "metering": "piston",
            "suctionPressure": "58 psig",
            "suctionLineTemp": "65 F",
            "wetBulb": 62,
            "outdoor": 90
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("jumblemog/refrigerant-charge-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": [
        "R-410A piston, suction 118 psig, suction line 60 F, liquid 340 psig, liquid line 98 F, 63 wet bulb, 85 outdoor",
        "R-454B TXV, suction 115 psig, suction line 55 F, liquid 400 psig, liquid line 105 F, target subcooling 9",
        "target superheat, 63 wet bulb, 85 outdoor",
        "R-407C at 45 F",
        "PT chart for R-32",
        "R-410A line set 50 ft, 3/8 liquid line, 15 ft included",
        {
            "refrigerant": "R-22",
            "metering": "piston",
            "suctionPressure": "58 psig",
            "suctionLineTemp": "65 F",
            "wetBulb": 62,
            "outdoor": 90,
        },
    ] }

# Run the Actor and wait for it to finish
run = client.actor("jumblemog/refrigerant-charge-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": [
    "R-410A piston, suction 118 psig, suction line 60 F, liquid 340 psig, liquid line 98 F, 63 wet bulb, 85 outdoor",
    "R-454B TXV, suction 115 psig, suction line 55 F, liquid 400 psig, liquid line 105 F, target subcooling 9",
    "target superheat, 63 wet bulb, 85 outdoor",
    "R-407C at 45 F",
    "PT chart for R-32",
    "R-410A line set 50 ft, 3/8 liquid line, 15 ft included",
    {
      "refrigerant": "R-22",
      "metering": "piston",
      "suctionPressure": "58 psig",
      "suctionLineTemp": "65 F",
      "wetBulb": 62,
      "outdoor": 90
    }
  ]
}' |
apify call jumblemog/refrigerant-charge-calculator --silent --output-dataset

```

## MCP server setup

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