10 min read

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.

ByAndré Ribeiro· Founder, Obelinf
Introducing Cooling Management in Obelinf
Introducing Cooling Management in Obelinf · November 14, 2026
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.

The cooling records from source to rack feed to device ports and back RECORDS IN THE COOLING CHAIN Source chiller or tower Feed loop to a rack Rack heat load Device intake cold side Device outflow warm return return path, back through the same feed One feed describes both directions of a loop. The intake records which outflow supplies it, so a coolant run can be traced from the load back through a CDU or manifold to the rack feed and the plant. source.rated_capacity_w / feed.capacity_w / rack.cooling_capacity_w

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.

Rack heat load summed from device power draw and compared with feed capacity HEAT LOAD ROLLUP Device power draw power_draw_w Device type fallback device_type.power_draw_w Heat load sum per rack Rack R07 example 3 servers x 8,000 W = 24,000 W feed capacity = 80,000 W utilization = 24,000 / 80,000 30 % The rack uses its own cooling capacity when one is set, and the sum of its feed capacities when it is not. A blank capacity produces an empty utilization value, never a zero. heat_load_w / feed_capacity_w / utilization_pct

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?
It tracks three layers: cooling sources such as chillers, cooling towers, dry coolers, and heat exchangers, feeds that carry a loop from a source to a rack, and the intake and outflow ports on each liquid cooled device. Device type templates create the ports automatically, and every rack and site card shows heat load against cooling capacity.
Is cooling management available on the free plan?
Yes. The free Personal plan includes 2 cooling sources and 8 cooling feeds, and device ports and templates are not metered. Paid plans remove those limits, and every plan can read the data through the API.
Does Obelinf replace a CDU, BMS, or DCIM monitoring system?
No. Obelinf is a documentation layer. It records what the plant and the racks contain, how the loops connect, and what the design capacities and temperatures are. Live telemetry, alarms, and valve control stay with the CDU controllers and the building management system.
How does Obelinf calculate rack heat load?
Heat load is the sum of the power draw of every device in the rack. A device uses its own power draw when one is recorded, otherwise it falls back to the power draw on its device type, and otherwise it contributes zero. Cooling utilization compares that heat load against the rack cooling capacity, or against the sum of its feed capacities when the rack has no capacity of its own.
Can I trace coolant from a server back to its source?
Yes, one hop at a time. A device intake can point at the outflow that supplies it, the device belongs to a rack, and the rack has one or more feeds that belong to a source. Obelinf stores the intake to upstream outflow link, not the reverse parent link on the outflow, so the trace runs from the load back toward the plant.
Do the REST API and MCP server support cooling records?
Yes. Sources and feeds have full REST endpoints, and the MCP server exposes tools for listing sources and feeds, creating them, and reading rack and device cooling summaries. A read only API key can read cooling records but cannot change them.

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