ForHosting KIT · Science

Monthly thermal amplitude calculator

Twelve temperate months whose mean maxima run from 4 to 29 °C and minima from −3 to 17 °C give monthly amplitudes of 7 to 12 degrees and an annual average just under 10. Compare stations or decades on one scale. Free in your browser.

Free
Runs in your browser
No sign-up
Your data stays on your device

Run — free How it works & API

Use it from WebAPIEmailTelegramApp soon

Monthly thermal amplitude is the difference between a month’s mean maximum temperature and its mean minimum temperature. Climatologists, agronomists, and building-energy analysts use that per-month range, and the arithmetic mean of those monthly ranges over a year, as a compact signature of continentality, cloudiness, and radiative cooling. A maritime station keeps nights mild and days moderate, so monthly amplitudes stay small; a dry continental interior swings harder, so the same statistic opens up. This monthly thermal amplitude calculator accepts two parallel arrays—monthly mean maxima and monthly mean minima—computes each month’s amplitude as maximum minus minimum, and returns the annual average amplitude as the mean of those monthly values.

What monthly thermal amplitude measures and how the annual average is formed

Monthly thermal amplitude is a standard climate-normals statistic, not a single day’s weather. For each calendar month you take the mean of that month’s daily maximum temperatures and the mean of that month’s daily minimum temperatures, then subtract. The result is the typical day–night envelope for that month, already averaged over the days that entered the monthly mean.

The annual average amplitude is then the arithmetic mean of those monthly envelopes. That two-step construction is how climate yearbooks, continentality discussions, and many agronomic heat-stress notes report thermal amplitude. It is a different search intent from diurnal temperature range on a named day: a daily series answers how much yesterday swung, while a monthly thermal amplitude series answers how wide the typical daily envelope is in January, in July, and on average over the year.

Maritime, cloudy, or humid climates compress the monthly amplitudes; dry, high-elevation, or strongly continental climates open them. You can compare two stations, or the same station across decades, by feeding their monthly mean maxima and minima into the same identity. This calculator does not convert units, gap-fill missing months, or invent a thirteenth value when you send eleven; it only evaluates A_i equals Tmax_mean_i minus Tmin_mean_i and the mean of those A_i.

Keep every value in the same unit—almost always degrees Celsius for operational climate work—and keep the two arrays aligned month for month so the annual average is a true mean of paired envelopes rather than a mix of unrelated seasons.

Who uses monthly thermal amplitude

Agriculture and phenology models use the annual average of monthly amplitudes as a continentality or cloudiness proxy when full radiation data are missing. Building-energy and comfort studies compare monthly envelopes between coastal and inland sites to size night-flush or heating strategies. Teaching labs and exam generators need a deterministic oracle that rejects misaligned monthly arrays instead of silently averaging a zip of leftover values.

Research notebooks reprocessing historical monthly climate normals can batch-evaluate annual average amplitude for many stations without standing up a full climate toolkit. Keep the two monthly arrays the same length, keep each month’s mean maximum at least its mean minimum, pin the rounded annual average in tests, and you get reproducible monthly thermal amplitude statistics for courses, docs, and edge workers without shipping a meteorology library to every client.

What you can do with it

Climate normals and station dashboards

Compute each month’s thermal amplitude and the annual average from monthly mean Tmax and Tmin archives for climate-normal tables and continentality panels.

Agriculture, buildings, and site comparison

Compare monthly envelopes and their annual mean between coastal and inland sites as a simple humidity, cloudiness, and night-cooling proxy.

FAQ

What happens if the monthly arrays have different lengths?

A maximum series that is longer or shorter than the minimum series cannot be paired month-for-month and is not billed.

Is this the same as diurnal temperature range?

No. Diurnal temperature range is a daily max-minus-min. This calculator uses monthly mean maxima and monthly mean minima, then averages those monthly amplitudes over the series.

Which temperature units should I use?

Use the same unit for every value in both arrays, typically °C.

How is the annual average thermal amplitude calculated?

Each month’s mean minimum is subtracted from its mean maximum, and the results are averaged. In the temperate example the monthly amplitudes run from 7 to 12 and add up to 119, so the annual average is 119/12, just under 10 degrees.

What does a large thermal amplitude say about a climate?

It points to a dry, high or strongly continental site, where days heat up and nights cool down sharply. Maritime, cloudy or humid places keep their monthly amplitudes small, so the figure works as a quick continentality signature.

Related tools

For developers — API access

Everything on this page is available programmatically. This section is for teams who want to wire it into their own systems; everyone else can just use the tool above.

API endpoint

POSThttps://api.kit.forhosting.com/earth/thermal-amplitude-series

Prefer to automate it? One authenticated POST creates the task; the result comes back by webhook or a signed link. The same capability also runs here on the web, by email and from Telegram — and soon from our app too.

Call it from your stack

curl -X POST https://api.kit.forhosting.com/earth/thermal-amplitude-series \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d '{"t_max_mean":[4,6,11,16,21,26,29,28,23,17,10,5],"t_min_mean":[-3,-2,1,5,10,14,17,16,12,7,2,-2]}'

const res = await fetch("https://api.kit.forhosting.com/earth/thermal-amplitude-series", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.KIT_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "t_max_mean": [
      4,
      6,
      11,
      16,
      21,
      26,
      29,
      28,
      23,
      17,
      10,
      5
    ],
    "t_min_mean": [
      -3,
      -2,
      1,
      5,
      10,
      14,
      17,
      16,
      12,
      7,
      2,
      -2
    ]
  })
});
const { task_id } = await res.json();

import os, requests

res = requests.post(
    "https://api.kit.forhosting.com/earth/thermal-amplitude-series",
    headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
    json={
    "t_max_mean": [
        4,
        6,
        11,
        16,
        21,
        26,
        29,
        28,
        23,
        17,
        10,
        5
    ],
    "t_min_mean": [
        -3,
        -2,
        1,
        5,
        10,
        14,
        17,
        16,
        12,
        7,
        2,
        -2
    ]
},
)
task_id = res.json()["task_id"]

<?php
$res = file_get_contents("https://api.kit.forhosting.com/earth/thermal-amplitude-series", false, stream_context_create([
  "http" => [
    "method"  => "POST",
    "header"  => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
    "content" => '{"t_max_mean":[4,6,11,16,21,26,29,28,23,17,10,5],"t_min_mean":[-3,-2,1,5,10,14,17,16,12,7,2,-2]}',
  ],
]));
$task = json_decode($res, true);

body := bytes.NewBufferString(`{"t_max_mean":[4,6,11,16,21,26,29,28,23,17,10,5],"t_min_mean":[-3,-2,1,5,10,14,17,16,12,7,2,-2]}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/earth/thermal-amplitude-series", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)

Example request

{
  "t_max_mean": [
    4,
    6,
    11,
    16,
    21,
    26,
    29,
    28,
    23,
    17,
    10,
    5
  ],
  "t_min_mean": [
    -3,
    -2,
    1,
    5,
    10,
    14,
    17,
    16,
    12,
    7,
    2,
    -2
  ]
}

Example response

{
  "task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
  "type": "earth.thermal_amplitude_series",
  "status": "queued",
  "_links": {
    "result": "/tasks/tsk_…/result"
  }
}

The API is asynchronous: the call returns a task_id immediately and the result arrives by webhook. Polling is capped at 1 req/s per task.

Pricing

Per request$0.002

Published price — no tokens, no invented credits. A failed task is never charged.

Errors

HTTP	Code	Meaning
`401`	`unauthorized`	Missing or invalid API key.
`402`	`insufficient_balance`	Your balance doesn't cover the task price.
`404`	`unknown_type`	That task type doesn't exist.
`429`	`rate_limited`	Too many requests. Use the webhook instead of polling.

Technical notes

When the two arrays differ in length the task fails with invalid_input so pipelines never pair January’s maximum with February’s minimum.

Input contract, response shape, and error behaviour

At least one month and at most one hundred twenty months are accepted so a decade of monthly climate normals can be scored in one call. Numeric strings are coerced when they parse as finite decimals. All numeric outputs are rounded to twelve decimal places for stable goldens across runtimes. Example: twelve temperate months with maxima four, six, eleven, sixteen, twenty-one, twenty-six, twenty-nine, twenty-eight, twenty-three, seventeen, ten, and five against minima negative three, negative two, one, five, ten, fourteen, seventeen, sixteen, twelve, seven, two, and negative two produce monthly amplitudes from seven to twelve and an annual average of one hundred nineteen twelfths. POST a JSON body with two required arrays of the same length: t_max_mean, the ordered monthly mean maxima, and t_min_mean, the ordered monthly mean minima. Each field may also use common aliases such as tmax_mean, max_mean, or monthly_max for the maxima and tmin_mean, min_mean, or monthly_min for the minima; the canonical names remain t_max_mean and t_min_mean. Missing arrays, non-array values, empty series, non-finite entries, and magnitudes beyond one million fail with invalid_input naming the problem. If any month’s mean maximum sits strictly below its matching mean minimum the request is also rejected so a negative nonsense amplitude never enters the annual average. On success the body includes month_count; annual_average_amplitude as the arithmetic mean of the monthly amplitudes; sum_amplitude; min_amplitude and max_amplitude over the series; unit temperature_degrees; formula and equation strings for display; a monthly array echoing each one-based month index with the rounded t_max_mean, t_min_mean, and amplitude; and steps for teaching UIs. Failed validation is not billed; successful analytic calls use the published $0.002 base price with no model tokens and no outbound network.

Where a monthly thermal amplitude series API earns its keep

Climate dashboards often need a monthly amplitude column beside mean temperature and precipitation totals; calling a tiny parse endpoint avoids embedding range logic in every language that touches the station feed.

Integration use cases

Teaching and QA oracles

Give students a deterministic monthly thermal amplitude check and reject any request where the two monthly arrays differ in length as invalid_input.

Technical questions

How do I calculate monthly thermal amplitude and the annual average?

Send t_max_mean and t_min_mean as two arrays of the same length. For each month A = t_max_mean − t_min_mean; the API returns those monthly amplitudes and annual_average_amplitude as their arithmetic mean.

What does the monthly thermal amplitude calculator cost?

The browser tool is free. API requests use prepaid balance at $0.002 per successful call; invalid input is not billed.

Read the full KIT documentation →

Run — free