# Fluid Properties: Steam Tables, Refrigerants, Psychrometrics (`jumblemog/fluid-properties`) Actor

Thermodynamic properties from plain text: steam tables, refrigerants (R134a, R410A, R32, CO2, ammonia), gases, glycol and brine, moist air with a psychrometric chart, refrigeration and Rankine cycles. SI or US units. For AI agents.

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

## Fluid Properties: Steam Tables, Refrigerants, Psychrometrics

**Look up thermodynamic properties the way you'd write them on paper.** Type `water: 10 bar, 300 C`, `R134a at -10 C, saturated vapor` or `30 C, 50% RH`, and get back temperature, pressure, density, specific volume, enthalpy, internal energy, entropy, quality, heat capacities, speed of sound, viscosity, thermal conductivity and more. It also handles:

- **Steam tables** of saturated liquid and vapor, by temperature or pressure.
- **Refrigeration and heat-pump cycles**, with COP, compressor work, discharge temperature and flows.
- **Rankine cycles**, with efficiency, back-work ratio, turbine exit quality and steam flow.
- **Moist air (psychrometrics)**, with all states plotted on a psychrometric chart.

The numbers come from [CoolProp](http://www.coolprop.org), the open-source library that implements the reference equations of state: IAPWS-95 for water, plus 120+ other fluids. Fluids include **water/steam**, refrigerants (**R134a, R410A, R32, R1234yf, R404A, R407C, R22, R290 propane, R600a isobutane, R744 CO₂, R717 ammonia**), gases (**air, nitrogen, oxygen, hydrogen, helium, methane, argon**), hydrocarbons and solvents, and **ethylene and propylene glycol** and **brine** solutions. Results come in **SI or US units** (°C, kPa, kJ/kg or °F, psia, Btu/lb), each with a one-line summary.

It's made for engineering students checking steam-table homework, HVAC technicians and designers, refrigeration and energy engineers, developers of calculators, and AI agents that need exact property values instead of guessing them.

![A temperature-entropy diagram from this Actor: a water Rankine cycle with reheat, 80 bar and 500 °C at the turbine, reheat at 10 bar to 500 °C, condenser at 10 kPa, drawn over the saturation dome; thermal efficiency 35.4%](https://api.apify.com/v2/key-value-stores/Km5b4PG3kYHdZSb1E/records/fluid-properties-example.png?signature=14puvuf9x6WLPLcjnlmSF)

### What it does

- **Fluid states** from any two properties: temperature, pressure, quality, enthalpy, entropy, internal energy, density or specific volume. Each value is recognized by its label (`h = 2800 kJ/kg`) or its unit (`10 bar`, `300 C`, `6.5 kJ/kg-K`). Words like `saturated liquid`, `saturated vapor` and `90% quality` work too.
  - Every state comes back with its phase, and its saturation temperature and degrees of superheat or subcooling.
  - One temperature or pressure alone gives **saturated liquid and vapor** side by side, with h_fg and s_fg.
- **Saturation tables**: `water from 0 to 100 C step 10`, or `water: 10 kPa to 20 MPa, 15 rows` (log-spaced). Each row has T, P, v, u, h and s of saturated liquid and vapor. The table comes as CSV, Markdown and a saturation-curve chart.
- **Refrigeration and heat-pump cycles**: evaporating and condensing temperatures, superheat, subcooling, compressor isentropic efficiency and capacity. Returns:
  - The four states, cooling and heating effects, compressor work and discharge temperature.
  - COP (cooling, heating and Carnot), pressure ratio and flash-gas quality.
  - With a capacity: refrigerant mass flow, compressor power and suction volume flow.
  - A **pressure-enthalpy (P-h) diagram**.
- **Rankine cycles**, steam or organic, with optional reheat. Returns:
  - Every state, heat in and out, turbine and pump work, net work and thermal efficiency.
  - Back-work ratio and turbine exit quality, with a warning below 88%.
  - With a power: the steam flow.
  - A **temperature-entropy (T-s) diagram**.
- **Moist air**: dry bulb with relative humidity, wet bulb, dew point or humidity ratio, or enthalpy with one of them. Pressure or altitude can be given. Returns wet bulb, dew point, RH, humidity ratio, enthalpy, specific volume, density and vapor pressure. All states go on a **psychrometric chart**, optionally joined as a process.
- **Reference states**: the fluid's usual one, or IIR, ASHRAE or NBP, to match the tables you're comparing with.
- **Batches**: up to 500 requests per run, mixed freely.

### Who it's for

- **Students** of thermodynamics and heat transfer: check steam-table lookups, interpolations, cycle homework and psychrometric problems, with charts.
- **HVAC and refrigeration technicians and engineers**: refrigerant saturation pressures, superheat and subcooling, cycle COP, coil and air-handling states.
- **Energy and process engineers**: steam and power-cycle estimates, gas and brine properties.
- **Developers**: a property API for calculators, apps and spreadsheets, with no library to install.
- **AI agents**: property values and cycle results in one call, instead of approximate numbers from memory.

### How to use it

1. Type **Fluid states**, one per line, such as `water: 10 bar, 300 C`.
2. Add **Saturation tables**, **Cycles** or **Moist air states** if you want them.
3. Leave **Units** on automatic (US units are picked when you write °F, psia or Btu), or choose SI or US.
4. Click **Start**. Each request is a row in the results, with its summary and chart.

### Examples

All of these ran on this Actor, and the numbers are from the results.

| Request | Result |
|---|---|
| `water: 10 bar, 300 C` | Superheated vapor: h = 3052 kJ/kg, s = 7.125 kJ/kg·K, v = 0.258 m³/kg, 120.1 K superheated |
| `steam: 150 psia, 500 F` | h = 1274 Btu/lb, s = 1.66 Btu/lb·R, v = 3.68 ft³/lb |
| `R134a at -10 C, saturated vapor` | 200.6 kPa, h = 392.7 kJ/kg, s = 1.733 kJ/kg·K |
| `steam at 100 C, quality 0.9` | 101.4 kPa, h = 2450 kJ/kg, v = 1.505 m³/kg |
| `water from 0 to 100 C step 10` | 11 rows from 0.01 °C (the triple point) to 100 °C; at 100 °C, 101.42 kPa and h_fg = 2256.4 kJ/kg |
| `30 C, 50% RH` | Wet bulb 22 °C, dew point 18.45 °C, humidity ratio 13.37 g/kg, enthalpy 64.36 kJ/kg dry air |
| `dry bulb 95 F, wet bulb 75 F` | 39.8% RH, dew point 66.77 °F, 98.95 gr/lb, 30.73 Btu/lb dry air |

**An R134a refrigeration cycle**: `{"type": "refrigeration", "fluid": "R134a", "evaporating": "-10 C", "condensing": "40 C", "superheat": "5 K", "subcooling": "3 K", "efficiency": 0.75, "capacity": "10 kW"}`

> R134a refrigeration cycle: COP 3.13 cooling (4.13 heating, Carnot 5.26), cooling effect 145 kJ/kg, compressor work 46.29 kJ/kg, discharge 61.88 °C, pressures 200.6 kPa to 1017 kPa (ratio 5.07). For 10 kW of cooling: 0.06897 kg/s of refrigerant, 3.193 kW of compressor power.

**A steam power plant with reheat** (the picture above): `{"type": "rankine", "fluid": "water", "boilerPressure": "80 bar", "turbineInlet": "500 C", "condenserPressure": "10 kPa", "turbineEfficiency": 0.85, "pumpEfficiency": 0.8, "netPower": "100 MW", "reheatPressure": "10 bar", "reheatTemperature": "500 C"}`

> Water Rankine cycle: thermal efficiency 35.4% (Carnot 58.7%), net work 1328 kJ/kg, heat in 3750 kJ/kg, back-work ratio 0.75%. For 100 MW net: 75.29 kg/s of steam, 282.4 MW of heat.

Textbook checks: the ideal Rankine cycle of Çengel's Example 10-1 (3 MPa, 350 °C, 75 kPa) comes out at 26.0% efficiency with 88.6% exit quality, and the reheat cycle of Example 10-4 at 45.0%. Both match the book.

### How-to examples

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

#### How to look up steam table properties

```json
{"states": ["water: 10 bar, 300 C", "steam at 100 C, quality 0.9"], "saturationTables": ["water from 0 to 100 C step 10"]}
```

Result: superheated vapor at 10 bar and 300 °C with h = 3052 kJ/kg, s = 7.125 kJ/kg·K and v = 0.258 m³/kg (120.1 K superheated); wet steam at 100 °C with h = 2450 kJ/kg; and a saturation table of 11 rows from the triple point to 100 °C, where h_fg = 2256.4 kJ/kg. US units work too: `steam: 150 psia, 500 F`.

#### How to calculate a refrigeration cycle's COP

```json
{"cycles": [{"type": "refrigeration", "fluid": "R134a", "evaporating": "-10 C", "condensing": "40 C", "superheat": "5 K",
             "subcooling": "3 K", "efficiency": 0.75, "capacity": "10 kW"}]}
```

Result: "R134a refrigeration cycle: COP 3.13 cooling (4.13 heating, Carnot 5.26), cooling effect 145 kJ/kg, compressor work 46.29 kJ/kg, discharge 61.88 °C, pressures 200.6 kPa to 1017 kPa (ratio 5.07). For 10 kW of cooling: 0.06897 kg/s of refrigerant, 3.193 kW of compressor power."

#### How to find dew point and wet bulb (psychrometrics)

```json
{"humidAir": ["30 C, 50% RH", "dry bulb 95 F, wet bulb 75 F"]}
```

Result: at 30 °C and 50% RH, a wet bulb of 22 °C, dew point 18.45 °C, humidity ratio 13.37 g/kg and enthalpy 64.36 kJ/kg dry air; at 95 °F dry bulb and 75 °F wet bulb, 39.8% RH and a dew point of 66.77 °F.

#### How to let an AI agent look up fluid properties

Add this Actor to the [Apify MCP server](https://mcp.apify.com) with `https://mcp.apify.com/?tools=jumblemog/fluid-properties`. The agent writes states the way an engineer would ("R134a at -10 C, saturated vapor") and uses real property values instead of recalled ones.

### FAQ

**Where do the properties come from?** CoolProp, the open-source property library, with the reference equations of state: IAPWS-95 for water, plus 120+ other fluids.

**Which fluids are there?** Water and steam, refrigerants such as R134a, R410A, R32 and R1234yf, R404A, R407C, R22, propane and isobutane, ammonia, CO2, air, nitrogen, hydrogen, methane and other gases, ethylene and propylene glycol and brine, plus moist air.

**Can I use US units?** Yes. Give the values in °F, psia and Btu/lb and the results come back in US units (`units` picks them automatically, or set `SI` or `US`).

**Does it do Rankine cycles?** Yes, with reheat, turbine and pump efficiencies and a net power. The textbook checks against Çengel's examples match the book.

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

### Input

| Field | What it is |
|---|---|
| `states` | Fluid states, one per line: the fluid, then two properties (`water: 10 bar, 300 C`). Objects such as `{"fluid": "nitrogen", "T": "77 K", "P": "1 atm"}` work too. |
| `fluid` | The fluid for lines that don't name one. |
| `saturationTables` | `<fluid> from <start> to <end> step <step>` or `..., <n> rows`, by temperature or pressure. |
| `cycles` | Objects. Refrigeration or heat pump: `type`, `fluid`, `evaporating`, `condensing`, `superheat`, `subcooling`, `efficiency`, `capacity`. Rankine: `fluid`, `boilerPressure`, `turbineInlet`, `condenserPressure` or `condenserTemperature`, `turbineEfficiency`, `pumpEfficiency`, `netPower`, `reheatPressure`, `reheatTemperature`. |
| `humidAir` | Moist-air states, one per line: `30 C, 50% RH`, `dry bulb 95 F, wet bulb 75 F`, `25 C, dew point 10 C, altitude 1500 m`, `24 C, W = 9 g/kg`. |
| `airPressure` / `altitude` | The pressure for moist-air lines that don't give one (default: sea level). |
| `connectAirStates` | Join the moist-air states in order on the chart, for a process. |
| `units` | `auto` (default), `SI` or `US`. |
| `referenceState` | `default`, `IIR`, `ASHRAE` or `NBP`: where enthalpy and entropy are zero. |

**Units it reads**:

- Temperature: C, F, K, R.
- Pressure: Pa, kPa, MPa, bar, mbar, atm, psi, psia, psig, barg, inHg, mmHg, torr.
- Enthalpy: J/kg, kJ/kg, Btu/lb, kcal/kg.
- Entropy: kJ/kg·K, Btu/lb·R.
- Density and specific volume: kg/m³, lb/ft³, m³/kg, ft³/lb.
- Humidity ratio: kg/kg, g/kg, gr/lb.
- Power: W, kW, MW, hp, Btu/h, tons.

Gauge pressures (`psig`, `barg`) add one standard atmosphere.

### Output

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

```json
{
  "request": 1,
  "status": "ok",
  "type": "state",
  "title": "Water: 10 bar, 300 C",
  "fluid": "Water",
  "phase": "gas (superheated vapor)",
  "properties": {
    "temperature": 300.0, "pressure": 1000.0, "density": 3.87615, "specificVolume": 0.257988,
    "enthalpy": 3051.63, "internalEnergy": 2793.64, "entropy": 7.12462, "quality": null,
    "cp": 2.14249, "cv": 1.60963, "speedOfSound": 578.485, "viscosity": 0.0202055,
    "thermalConductivity": 0.0451222, "prandtl": 0.959394, "compressibilityFactor": 0.975309,
    "molarMass": 18.0153, "saturationTemperature": 179.878, "superheat": 120.122
  },
  "unitLabels": {"temperature": "°C", "pressure": "kPa", "enthalpy": "kJ/kg", "entropy": "kJ/kg·K", "...": "..."},
  "summary": "Water, gas (superheated vapor): 300 °C, 1000 kPa, h = 3052 kJ/kg, s = 7.125 kJ/kg·K, v = 0.258 m³/kg, density 3.876 kg/m³, 120.1 K superheated."
}
```

Each request type adds its own fields:

- **Saturation** requests have `liquid`, `vapor`, `hfg` and `sfg`.
- **Tables** have `rows`, `csvUrl`, `imageUrl` and `markdownUrl`.
- **Cycles** have `states` (each point's T, P, h, s, density and quality), `results` (COP or efficiency, works, heats and flows), `imageUrl` and `svgUrl` (the diagram) and `markdownUrl`.
- **Moist-air** items have `properties` (dry bulb, wet bulb, dew point, RH, humidity ratio, enthalpy, specific volume, density, vapor pressure) and the psychrometric chart in `imageUrl`.

A request that can't be computed has `"status": "failed"` and the reason in `error`, and isn't billed.

### How it works

1. Each line is read into a fluid and two properties in SI units. A property is recognized by its label or its unit, and gauge pressures are converted.
2. CoolProp's Helmholtz-energy equations of state give the state: IAPWS-95 for water, and the reference equations for each refrigerant and gas. Transport properties come from CoolProp's correlations. Glycol and brine solutions use its incompressible-liquid fits, and moist air uses the ASHRAE RP-1485 model.
3. Blends that CoolProp models as single pseudo-pure fluids (R404A, R407C, R410A, R507A, air) have no two-phase states of their own. A two-phase state of one is mixed from its saturated liquid and vapor by mass, and the result says so.
4. Cycles are built state by state. The evaporator is at the dew point and the condenser at the bubble point. Compressor, pump and turbine outlets come from the isentropic state and the efficiency.
5. Charts are drawn with Vega-Lite and rendered with vl-convert.

### Pricing

You pay per result, at the prices shown on this page:

- One price per **state**: a fluid state, saturation point or moist-air state.
- A higher price per **table or cycle**, with its chart, CSV and report 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 state takes a few milliseconds and a cycle with its chart about a second. A run through the API answers in about 5 to 10 seconds, including the cloud container starting.

### Tips and limits

- **Two properties fix a state**: temperature and pressure don't fix a two-phase state, so give the quality (or enthalpy or entropy) for a mixture.
- **Reference states**: enthalpy and entropy differences don't depend on the reference, but absolute values do. Steam tables use IAPWS (u = s = 0 for liquid at the triple point), which is the default. For refrigerants the default is IIR (h = 200 kJ/kg at 0 °C), and many US textbooks use ASHRAE (h = s = 0 for liquid at -40 °C).
- **Transcritical CO₂ cycles** (condensing above the critical temperature) aren't covered by the refrigeration cycle. Individual CO₂ states at any pressure work.
- **Glycols and brines** take temperature and pressure only (they're liquids). The result gives the freezing point.
- **Moist air** must not be supersaturated: a relative humidity over 100% or a wet bulb above the dry bulb is refused with the reason.
- **Limits**: 500 requests per run, tables up to 1000 rows.

### 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 `states` as text lines (or `humidAir`, `saturationTables`, `cycles`) and read `summary` and `properties` from the result. A direct API call that waits for the answer:

```bash
curl -X POST "https://api.apify.com/v2/acts/jumblemog~fluid-properties/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"states": ["water: 10 bar, 300 C", "R410A at 5 C, saturated vapor"], "humidAir": ["30 C, 50% RH"]}'
```

`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/fluid-properties").call(run_input={
    "units": "US",
    "states": ["steam: 150 psia, 500 F", "R134a at 20 F, saturated"],
    "cycles": [{"type": "heat pump", "fluid": "R410A", "evaporating": "30 F", "condensing": "110 F",
                "superheat": "10 F", "subcooling": "10 F", "efficiency": "70%", "capacity": "3 tons"}],
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["summary"])
```

### Credits

- Properties: [CoolProp](http://www.coolprop.org) by Ian Bell and contributors (MIT). Bell, I. H., Wronski, J., Quoilin, S., Lemort, V. (2014), *Pure and Pseudo-pure Fluid Thermophysical Property Evaluation and the Open-Source Thermophysical Property Library CoolProp*, Ind. Eng. Chem. Res. 53(6), 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

## `states` (type: `array`):

One state per line: the fluid, then two properties with units or labels, such as 'water: 10 bar, 300 C', 'steam: P = 150 psia, h = 1300 Btu/lb', 'R134a at -10 C, saturated vapor', 'ammonia at 10 bar, 90% quality', 'CO2: 100 bar, 40 C', 'propylene glycol 30%: 20 C'. One temperature or pressure alone gives saturated liquid and vapor ('water at 100 C'). Properties: T, P, quality (x), h, s, u, density, specific volume.

## `fluid` (type: `string`):

The fluid for state lines that don't name one, such as water or R134a.

## `saturationTables` (type: `array`):

Steam-table style tables of saturated liquid and vapor: 'water from 0 to 100 C step 10', 'R134a: -40 to 60 C every 5', 'water: 10 kPa to 20 MPa, 15 rows' (pressure tables with a wide range are spaced evenly on a log scale).

## `cycles` (type: `array`):

Refrigeration or heat-pump cycles: {"type": "refrigeration", "fluid": "R134a", "evaporating": "-10 C", "condensing": "40 C", "superheat": "5 K", "subcooling": "3 K", "efficiency": 0.75, "capacity": "10 kW"}. Rankine cycles: {"type": "rankine", "fluid": "water", "boilerPressure": "80 bar", "turbineInlet": "500 C", "condenserPressure": "10 kPa", "turbineEfficiency": 0.85, "pumpEfficiency": 0.8, "netPower": "100 MW", "reheatPressure": "10 bar", "reheatTemperature": "500 C"}.

## `humidAir` (type: `array`):

One moist-air state per line: dry bulb with relative humidity, wet bulb, dew point or humidity ratio ('30 C, 50% RH', 'dry bulb 95 F, wet bulb 75 F', '25 C, dew point 10 C', '24 C, W = 9 g/kg'), or enthalpy with one of them. Add a pressure or 'altitude 1500 m' to a line, or set it for all below. All states are plotted on one psychrometric chart.

## `airPressure` (type: `string`):

Barometric pressure for moist-air lines that don't give one, such as 101.325 kPa or 12.2 psia. Empty: sea level.

## `altitude` (type: `string`):

Instead of the pressure: an altitude such as 1500 m or 5000 ft (standard atmosphere).

## `connectAirStates` (type: `boolean`):

Draw a line through the moist-air states in order on the chart, for a process such as cooling and reheating.

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

Units of bare numbers and of the results. Automatic picks US when most units written are US units.

## `referenceState` (type: `string`):

The zero point of enthalpy and entropy. Differences (and cycle results) don't change; match the tables you're comparing with. Many US textbooks use ASHRAE for refrigerants.

## Actor input object example

```json
{
  "states": [
    "water: 10 bar, 300 C",
    "R134a at -10 C, saturated vapor",
    "steam at 100 C, quality 0.9",
    "R410A: 1200 kPa, 40 C"
  ],
  "saturationTables": [
    "water from 0 to 100 C step 10"
  ],
  "cycles": [
    {
      "type": "refrigeration",
      "fluid": "R134a",
      "evaporating": "-10 C",
      "condensing": "40 C",
      "superheat": "5 K",
      "subcooling": "3 K",
      "efficiency": 0.75,
      "capacity": "10 kW"
    }
  ],
  "humidAir": [
    "30 C, 50% RH",
    "dry bulb 95 F, wet bulb 75 F"
  ],
  "connectAirStates": false,
  "units": "auto",
  "referenceState": "default"
}
```

# 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, CSV tables 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 = {
    "states": [
        "water: 10 bar, 300 C",
        "R134a at -10 C, saturated vapor",
        "steam at 100 C, quality 0.9",
        "R410A: 1200 kPa, 40 C"
    ],
    "saturationTables": [
        "water from 0 to 100 C step 10"
    ],
    "cycles": [
        {
            "type": "refrigeration",
            "fluid": "R134a",
            "evaporating": "-10 C",
            "condensing": "40 C",
            "superheat": "5 K",
            "subcooling": "3 K",
            "efficiency": 0.75,
            "capacity": "10 kW"
        }
    ],
    "humidAir": [
        "30 C, 50% RH",
        "dry bulb 95 F, wet bulb 75 F"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("jumblemog/fluid-properties").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 = {
    "states": [
        "water: 10 bar, 300 C",
        "R134a at -10 C, saturated vapor",
        "steam at 100 C, quality 0.9",
        "R410A: 1200 kPa, 40 C",
    ],
    "saturationTables": ["water from 0 to 100 C step 10"],
    "cycles": [{
            "type": "refrigeration",
            "fluid": "R134a",
            "evaporating": "-10 C",
            "condensing": "40 C",
            "superheat": "5 K",
            "subcooling": "3 K",
            "efficiency": 0.75,
            "capacity": "10 kW",
        }],
    "humidAir": [
        "30 C, 50% RH",
        "dry bulb 95 F, wet bulb 75 F",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("jumblemog/fluid-properties").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 '{
  "states": [
    "water: 10 bar, 300 C",
    "R134a at -10 C, saturated vapor",
    "steam at 100 C, quality 0.9",
    "R410A: 1200 kPa, 40 C"
  ],
  "saturationTables": [
    "water from 0 to 100 C step 10"
  ],
  "cycles": [
    {
      "type": "refrigeration",
      "fluid": "R134a",
      "evaporating": "-10 C",
      "condensing": "40 C",
      "superheat": "5 K",
      "subcooling": "3 K",
      "efficiency": 0.75,
      "capacity": "10 kW"
    }
  ],
  "humidAir": [
    "30 C, 50% RH",
    "dry bulb 95 F, wet bulb 75 F"
  ]
}' |
apify call jumblemog/fluid-properties --silent --output-dataset

```

## MCP server setup

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

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/DIBH9mIJbwNZ7ETY0/builds/HVTc7zHSwvl2qEP4E/openapi.json