Introducing Cooling Management in Obelinf
Obelinf now documents cooling sources, rack feeds, and device coolant ports next to your power and rack data, and derives heat load from the power draw you already record.

On this page
Cooling has always been the part of the data center that lives in two places at once: a plant drawing in the facilities office and a spreadsheet of rack loads that someone maintains until they change jobs. The racks are documented, the power is documented, and the coolant loop that actually keeps the GPUs alive is still described in an email thread. When a CDU is added, a rack is converted to direct to chip, or a feed is rebalanced, the inventory and the building drift apart.
Obelinf now documents cooling with the same conventions as power: a source, a feed, and a port on the device, each with a real record you can query, link, and audit. You can add cooling sources and feeds next to your racks, devices, and power paths, and the rack and site pages start reporting heat load and cooling utilization from the power data you already maintain.
At a Glance: Where Cooling Records Live
| Obelinf | Spreadsheet | NetBox | |
|---|---|---|---|
| Cooling model | Sources, feeds, device ports, templates | Free text columns | Sources, feeds, intakes, outflows, templates |
| Capacity units | Watts, liters per minute, millimeters | Whatever the author chose | Flow unit is selectable |
| Heat load | Derived from device power draw | Manual estimate | Not derived from power |
| Where it shows up | Rack, site, and device cards | Separate file | List and detail pages |
| Change history | Immutable, field level | File versions | Object change log |
| API and agent access | REST API + MCP | None | REST API + GraphQL |
| Cost | Free tier, Enterprise custom | Free (your time) | Free |
The Plant Starts With a Source Record
A cooling source is one cooling or heat rejection asset at one site: a chiller, a cooling tower, a dry cooler, a CRAC or CRAH unit, a heat exchanger, or something else you name. Each source carries a name, a slug that is unique inside your organization, the site it belongs to, its status, the fluid it handles, and a rated capacity in watts. The status values follow the power model: active, planned, maintenance, offline, failed, and retired.
Site scope is deliberate. Obelinf does not have a location hierarchy, so a source belongs to a site rather than to a room or a hall. That matches how power panels are recorded today and keeps the record honest: if your chiller serves the whole building, claiming it serves one room would be false precision. The fluid field is a short list (water, water-glycol, dielectric, refrigerant, other) because the chemistry detail belongs in the feed temperatures and in your maintenance system, not in a free text field that nobody can query.
The rated capacity is optional, and that is intentional. A planned chiller may have no nameplate figure yet, and a cooling tower may be shared across several loops in a way that makes a single capacity misleading. Record it when the number is real. A blank capacity is a known gap, while a guessed capacity is a false ceiling that every later utilization report will inherit.
A Feed Is One Loop to One Rack
A feed connects a source to a rack, and it carries the design numbers that matter at the row: capacity in watts, maximum flow in liters per minute, and supply and return temperatures in Celsius. The feed name is the loop name your team already uses, for example R07-L1. The rack is optional until the loop is installed, which lets you record a planned feed without pretending the rack exists yet.
A feed is not two records. It describes both the supply and the return path of one loop, because that is how a row manifold and a rack CDU are installed: one loop, two directions. Storing separate supply and return feeds doubles the record count and creates a pairing problem that adds no information. When the physical design really does have independent supply and return paths, create two feeds and name them so the pair is obvious.
Feed capacity and source capacity are separate on purpose. A 400 kW chiller can feed several 80 kW rack loops, and a rack can receive a loop that was provisioned at 60 kW even though the plant has 2 MW behind it. If you roll up only the source number, the rack report looks comfortable right up until the row is fully populated. The rack card sums the capacity of the feeds that actually serve it, and the source card sums the feeds that actually hang off that source.
Device Ports and Templates
A liquid cooled device has at least one intake and one outflow. Each port carries a name, an optional label for the physical silkscreen, a connector type, a diameter in millimeters, a maximum flow in liters per minute, and a description. The connector list is shared across the product: uqd, uqdb, qdc, camlock, npt, bsp, and other. Diameter is stored in millimeters and flow in liters per minute, because a port spec that mixes inches and gallons per minute is a conversion error waiting to happen.
Ports are usually identical across a fleet, so they live on the device type as templates. Define the intake and outflow templates once, and every device of that type gets the same ports when it is created. If a device was created before the template existed, the apply endpoint creates the missing ports without duplicating the ones already there. The template holds the design intent, and the device port holds the installed reality, so a technician can relabel a port or correct a connector without touching every server of that model.
The intake has one relationship the outflow does not: cooling_outflow_id. That field points at the outflow that supplies the intake, which is how a server intake can be tied to the CDU or manifold port that feeds it. The reverse reference is not stored, because the same outflow can supply several downstream intakes and a single parent field would force you to pick one. Trace from the load outward, and the chain stays unambiguous.
Heat Load Comes From the Power You Already Record
Almost all of the electricity that enters a rack leaves it as heat, so Obelinf does not ask you for a second, separately maintained heat number. Heat load for a device is its own power draw when one is recorded, otherwise the power draw on its device type, otherwise zero. Rack heat load is the sum of the devices in the rack, and site heat load is the sum of the devices in racks at the site.
Utilization compares that heat load against the rack cooling capacity when the rack has one, and against the sum of the rack feed capacities when it does not. That fallback matters during a migration: a converted rack may have a feed and a working loop before anyone fills in the rack capacity, and the report should still show a number instead of a blank. When neither value exists, utilization is empty rather than zero, because zero would imply the rack is idle.
The Records Appear Where You Work
The cooling data is not a separate workspace you have to remember to visit. Source and feed pages live under Cooling in the sidebar, with list, detail, create, and edit screens that follow the same pattern as power. The device page gains a cooling card with the method, the ports, the total maximum flow, and the rack feed that serves it. The rack page gains a cooling card with heat load, feed capacity, utilization, and port counts. The site page rolls those numbers up into a source count, feed count, feed capacity, heat load, and liquid device count.
Every one of those records supports tags, custom fields, search, changelog, and the same role and API key permissions as the rest of the inventory. A cooling feed with a custom field for maintenance contract, a tag for a customer, or a changelog entry that shows a capacity change last Tuesday works exactly like a power feed or a subnet, because it is the same machinery.
Read and Write It Over the API
A source is one POST, and a feed is another. The requests below use the same base URL and bearer token as every other Obelinf endpoint.
cat > source-chiller.json <<JSON
{
"name": "Chiller 1",
"slug": "nyc1-chiller-1",
"site_id": "${SITE_ID}",
"type": "chiller",
"status": "active",
"fluid": "water-glycol",
"rated_capacity_w": 400000,
"description": "Primary chilled water plant"
}
JSON
curl --fail --silent --show-error -X POST \
-H "Authorization: Bearer ${OBELINF_API_KEY}" \
-H "Content-Type: application/json" \
--data @source-chiller.json \
"${API}/cooling/sources" \
| jq '.cooling_source | {id, name, type, fluid, rated_capacity_w}'
The response wraps the record in cooling_source, and the id is what the feed needs. The same shape applies to cooling_feed, cooling_intake, and cooling_outflow:
curl --fail --silent --show-error -X POST \
-H "Authorization: Bearer ${OBELINF_API_KEY}" \
-H "Content-Type: application/json" \
-d "{\"name\":\"R07-L1\",\"cooling_source_id\":\"${SOURCE_ID}\",\"rack_id\":\"${RACK_ID}\",\"status\":\"active\",\"capacity_w\":80000,\"max_flow_lpm\":45,\"supply_temp_c\":18,\"return_temp_c\":27}" \
"${API}/cooling/feeds" \
| jq '.cooling_feed | {id, name, rack_name, capacity_w, max_flow_lpm}'
Reading the rack summary is a single call, and it is the fastest way to check a conversion before the rack goes live:
curl --fail --silent --show-error \
-H "Authorization: Bearer ${OBELINF_API_KEY}" \
"${API}/cooling/summary/rack/${RACK_ID}" \
| jq '{rack_name, cooling_capability, feed_capacity_w, heat_load_w, utilization_pct, liquid_device_count}'
{
"rack_name": "R07",
"cooling_capability": "liquid",
"feed_capacity_w": 80000,
"heat_load_w": 24000,
"utilization_pct": 30,
"liquid_device_count": 3
}
The MCP server exposes the same data to an agent through list_cooling_sources, create_cooling_source, list_cooling_feeds, get_cooling_feed, create_cooling_feed, get_rack_cooling, and get_device_cooling. An assistant with a read only key can answer which racks are close to their cooling limit without being able to change a capacity.
What It Costs
Cooling management is available on every plan. The free Personal plan includes 2 cooling sources and 8 cooling feeds, which covers a homelab or a small lab with a single loop. Ports and templates are not metered, so a rack full of liquid cooled servers does not consume the plan limit. Paid plans remove the source and feed caps, and the full breakdown is on the pricing page.
Start With the Loop You Can Trace
The useful first step is not a full plant survey. Pick one rack that already has a loop, record its source, its feed, and the ports on the devices inside it, then read the rack summary and compare the heat load against the feed capacity. If the numbers look wrong, you have found either a missing device power draw or a feed capacity that was never real, and both are worth fixing before you repeat the process for the next row. The rack management and device inventory records give you the anchors, and the cooling layer fills in the part that used to live in the spreadsheet.
You can create an account for free at obelinf.com and add your first cooling source in a few minutes.
Frequently Asked Questions
What does cooling management in Obelinf track?
Is cooling management available on the free plan?
Does Obelinf replace a CDU, BMS, or DCIM monitoring system?
How does Obelinf calculate rack heat load?
Can I trace coolant from a server back to its source?
Do the REST API and MCP server support cooling records?
Stop reaching for a spreadsheet
Obelinf keeps every subnet, device, circuit, and rack in one live source of truth, with audit logs and a topology view. Free for personal use.
Related Articles

How to Document Cooling Sources, Feeds, and Device Intakes
A working procedure for building a cooling record from the plant to the cold plate: the order to create each record, the API calls, the fields that matter, and the checks that catch gaps.
Read more
How to Document Power Sources, Panels, Breakers, and Feeds
A working procedure for building a power distribution record from source to rack: the order to create each record, the API calls, the fields that matter, and the checks that catch gaps.
Read more
Direct to Chip vs Rear Door vs Immersion Cooling
How direct to chip, rear door, and immersion liquid cooling compare on density, PUE, cost, and retrofit fit, and how to choose between them for your data center.
Read more