# Frost Dates & Growing Degree Days Calculator (`jumblemog/growing-season-calculator`) Actor

Frost dates with 1-in-10 odds, frost-free season, vegetable planting calendar, and growing degree days for corn, grapes and other crops vs the average, for any place from NASA daily temperatures since 2001.

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

## Frost Dates & Growing Degree Days Calculator

**Frost dates, the growing season, a planting calendar and growing degree days for any place in the world, from one line of text.** Ask `frost dates for Minneapolis`, `when to plant tomatoes, peppers, peas and lettuce in Denver` or `growing degree days for corn in Des Moines planted May 1` and you get back:

- **Frost dates**: the median last spring and first autumn frost at 36°F (frost on the ground likely), 32°F (light freeze) and 28°F (hard freeze), with the 1-in-10 dates (90% of years are past the last frost by then) and the frost-free season in days.
- **Every year since 2001**: each year's last and first frost dates and frost-free days.
- **A planting calendar**: when to start seeds indoors and plant out tomatoes, peppers, peas, lettuce and 20 more vegetables, and the first harvest, from the median last frost. It warns when a tender crop won't ripen before the first autumn frost.
- **Growing degree days**: this season's total for a crop (corn, soybeans, wheat, cotton, alfalfa, potatoes, grapes and more) or any base temperature from a planting date, against the 2001-2025 average and its 1-in-10 range, with how this season ranks, when a target (2,700 GDD for corn) is or should be reached, and the **Winkler index** and region for vineyards.
- **A chart**: each year's frost-free season, or the degree days through the season against the average.

It's made for:

- Gardeners and allotment holders deciding when to sow and plant out.
- Farmers and agronomists tracking crop development, corn maturity and pest timing.
- Vineyard planners comparing sites by the Winkler index.
- Seed companies, garden apps, extension services and AI agents that need frost dates and degree days for any place, not just US ZIP codes.

![A chart made by this Actor of the frost-free season in Minneapolis for every year from 2001 to 2025: green bars from the last spring frost to the first autumn frost, the median last frost around April 29 and the first around October 10](https://api.apify.com/v2/key-value-stores/Km5b4PG3kYHdZSb1E/records/growing-season-calculator-example.png?signature=RqoMHOMdDYudNbs07s0N)

### How to use it

1. Write **Places and questions**, one per entry. The form has examples.
2. Optionally set the **Units**: °F in the US and °C elsewhere by default.
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 |
|---|---|
| `Minneapolis`, `Leeds, UK`, `Christchurch, New Zealand`, `44.98, -93.27` | Where (a town of 5,000+ people or coordinates) |
| `frost dates for ...`, `last frost`, `growing season` | Frost dates |
| `when to plant tomatoes and peas in ...`, `planting calendar for ...` | A planting calendar (named crops, or 12 common vegetables) |
| `growing degree days for corn in ...`, `GDD`, `heat units` | Degree days for a crop |
| `base 10°C`, `base 50°F`, `cap 86°F` | Your own base and upper threshold |
| `planted May 1`, `since April 15`, `2,600 GDD`, `2012` | Start date, target and season |
| `Winkler index for Napa` | Grapes: degree days above 50°F, 1 April to 31 October |

The same as an object: `{"place": "Guelph, Canada", "type": "frost", "crops": ["tomato", "bean"]}` or `{"lat": 48.85, "lon": 2.35, "base": 10, "units": "metric", "start": "04-01"}`.

### Examples

- `frost dates for Minneapolis` → last spring frost (32°F) around Apr 29 (1 year in 10 after May 16), first autumn frost around Oct 10 (1 in 10 before Oct 3); 164 frost-free days. NOAA's 1991-2020 normals for the airport are about Apr 30 and Oct 8.
- `when to plant tomatoes, peppers, peas and lettuce in Denver` → last frost around May 14: start tomatoes indoors Mar 19-Apr 2 and plant out May 21-Jun 4; sow peas Apr 2-16.
- `growing degree days for corn in Des Moines, Iowa planted May 1` → 3,565 °F GDD to Oct 21 2026, 9% ahead of the 2001-2025 average; 2,700 GDD reached Aug 31 (normally Sep 8).
- `Winkler index for Walla Walla, Washington` → 1,978 in a normal season (region I).
- `planting calendar for Leeds, UK` → last frost (0°C) around Apr 18, first around Nov 17, and when to sow 12 vegetables.
- `frost dates for Christchurch, New Zealand` → southern seasons: last spring frost around Sep 3, first autumn frost around Jun 11.

### How-to examples

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

#### How to find the last frost date for your town

```json
{"requests": ["frost dates for Minneapolis"]}
```

Result: "Minneapolis: last spring frost (32°F) around Apr 29 (1 year in 10 after May 16), first autumn frost around Oct 10 (1 in 10 before Oct 3); 164 frost-free days in a typical year." NOAA's 1991-2020 normals for the airport are about Apr 30 and Oct 8.

#### How to know when to plant vegetables

```json
{"requests": ["when to plant tomatoes, peppers, peas and lettuce in Denver"]}
```

Result: last frost around May 14, so start tomatoes indoors Mar 19-Apr 2 and plant them out May 21-Jun 4, and sow peas Apr 2-16. It works anywhere: `planting calendar for Leeds, UK` gives frost dates at 0°C and when to sow 12 vegetables, and southern-hemisphere places get southern seasons.

#### How to track growing degree days for a crop

```json
{"requests": ["growing degree days for corn in Des Moines, Iowa planted May 1"]}
```

Result: 3,565 °F GDD to Oct 21 2026, 9% ahead of the 2001-2025 average, with 2,700 GDD reached on Aug 31 (normally Sep 8). Grape growers can ask for the Winkler index: 1,978 for Walla Walla, Washington (region I).

#### How to let an AI agent answer gardening questions

Add this Actor to the [Apify MCP server](https://mcp.apify.com) with `https://mcp.apify.com/?tools=jumblemog/growing-season-calculator`. The agent passes the question as written and answers with frost dates and planting windows from 25 years of daily temperatures for the place, instead of a hardiness-zone guess.

### FAQ

**Where does the data come from?** NASA POWER's daily highs and lows for the place, from 2001 to a few days ago.

**What does "1 year in 10" mean?** The frost date is a typical date; in 1 year out of 10 the last spring frost comes later than the second date. Planting after it is safer.

**Does it work outside the US?** Yes, anywhere in the world, in °F or °C.

**Can it track this season?** Yes. Growing degree days run to a few days ago and are compared with the average. This season's numbers come from NASA's near-real-time analysis, so treat the comparison as approximate.

### Input

| Field | What it is |
|---|---|
| `requests` | Places and questions, as lines of text or objects (up to 200 per run) |
| `units` | `auto` (°F in the US, °C elsewhere), `us` or `metric` |
| `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": "frost", "title": "Frost dates for Minneapolis",
  "summary": "Minneapolis: last spring frost (32°F) around Apr 29 (1 year in 10 after May 16), first autumn frost around Oct 10 (1 in 10 before Oct 3); 164 frost-free days in a typical year.",
  "frost": {"lastSpringFrost": "Apr 29", "firstFallFrost": "Oct 10", "growingSeasonDays": 164,
            "lastSpringFrost90": "May 16", "firstFallFrost10": "Oct 3", "threshold": "32°F", "yearsUsed": "2001-2025"},
  "thresholds": [{"threshold": "32°F", "meaning": "light freeze", "lastSpring10": "Apr 21", "lastSpring50": "Apr 29",
                  "lastSpring90": "May 16", "firstFall10": "Oct 3", "firstFall50": "Oct 10", "firstFall90": "Oct 25",
                  "growingSeason50": 164, "yearsWithFrost": 25, "years": 25}, "..."],
  "years": [{"season": "2001", "lastSpringFrost": "2001-04-24", "firstFallFrost": "2001-10-06", "frostFreeDays": 164}, "..."],
  "calendar": null,
  "units": {"temperature": "°F", "degreeDays": "°F GDD"},
  "imageUrl": "https://api.apify.com/v2/key-value-stores/.../records/001-Frost-dates-for-Minneapolis.png"
}
```

Degree-day items have `gdd` (crop, base, cap, method, start, through, accumulated, normalToDate, departure, departurePercent, normalSeasonTotal, rankWarmest, target, targetDate, normalTargetDate, winklerIndex, winklerRegion) and `monthly` instead. Every item also has `place`, `warnings`, `notes` (the method and every assumption), 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. **Temperatures**: NASA POWER's daily 2 m highs and lows for the point from 2001 to a few days ago (MERRA-2 reanalysis, then NASA's near-real-time GEOS analysis).
2. **Frost**: in each year, the last day before midsummer and the first day after it with a low at or below the threshold (midwinter is 15 January in the north and 15 July in the south). The median and the 10th and 90th percentiles over the years give the dates, as in NOAA's freeze tables.
3. **Planting calendar**: weeks before or after the median last frost for each crop (peas 6-4 weeks before, tomatoes 1-3 weeks after, seeds indoors 6-10 weeks before), plus typical days to harvest.
4. **Degree days**: each day's average of high and low less the base (never below zero); for corn and soybeans the modified method raises the low to 50°F and caps the high at 86°F. Summed from the start date, against the average and the 10th-90th percentile of 2001-2025.

### Pricing

You pay one low price per request, at the price shown on this page. The chart 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 about a second (25 years of daily data for a place is fetched once per run). A run through the API answers in about 10-15 seconds, including the cloud container starting.

### Tips and limits

- **Grid cells**: the temperatures are for a cell about 50 km across. Low spots and valleys frost earlier in autumn and later in spring than the cell, and city centres and coasts less; use the 1-in-10 dates for frost-tender plants.
- **This season** comes from NASA's near-real-time analysis, which can differ from the long record the average uses; treat its departure from the average as approximate.
- **Planting windows** are rules of thumb; seed packets and local extension services know your varieties.
- **Limits**: 200 requests per run; places need NASA POWER to answer.

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

```bash
curl -X POST "https://api.apify.com/v2/acts/jumblemog~growing-season-calculator/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"requests": ["when to plant tomatoes and beans in Madison, Wisconsin"]}'
```

`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/growing-season-calculator").call(run_input={
    "requests": [{"place": "Lincoln, Nebraska", "crop": "corn", "start": "05-05", "target": 2600}],
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["summary"])
```

### Credits

- Temperatures: [NASA POWER](https://power.larc.nasa.gov) (NASA Langley Research Center POWER Project, funded through the NASA Earth Science Directorate Applied Science Program; public).
- Places: [GeoNames](https://www.geonames.org) via [geonamescache](https://github.com/yaph/geonamescache) (CC BY 4.0, MIT).
- Math: [NumPy](https://numpy.org) (BSD-3-Clause). 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).
- Methods: NOAA freeze probability tables; the modified growing degree day method (McMaster and Wilhelm 1997); the Winkler index (Amerine and Winkler 1944).

# Actor input Schema

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

One request per entry, as a line of text or an object. Say where (a town or city of 5,000+ people, with the US state or country if needed, or coordinates); the daily temperatures since 2001 come from NASA POWER. Frost: 'frost dates for Minneapolis' gives the last spring and first autumn frost (36, 32 and 28°F) with 1-in-10 odds and the frost-free season; name vegetables ('when to plant tomatoes and peas in Denver', 'planting calendar for Leeds') for a planting calendar. Degree days: 'growing degree days for corn in Des Moines planted May 1', 'GDD base 10°C in Lyon since April 1', '2,600 GDD', '2012', 'Winkler index for Napa'. Crops: corn, soybean, sorghum, cotton, wheat, barley, oats, alfalfa, canola, sunflower, potato, tomato, rice, peas, grapes, turf. Object fields: type (frost or gdd), place, lat, lon, crops, crop, base, cap, start ('05-01'), target, year, units, title, text.

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

Temperatures and degree days. °F or °C written in a request wins; object bases and caps are in these units.

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

Each year's frost-free period, or degree days through the season against the average.

## Actor input object example

```json
{
  "requests": [
    "frost dates for Minneapolis",
    "when to plant tomatoes, peppers, peas and lettuce in Denver",
    "growing degree days for corn in Des Moines, Iowa planted May 1",
    "Winkler index for Walla Walla, Washington",
    "frost dates for Christchurch, New Zealand",
    {
      "lat": 48.85,
      "lon": 2.35,
      "base": 10,
      "units": "metric",
      "start": "04-01"
    }
  ],
  "units": "auto",
  "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": [
        "frost dates for Minneapolis",
        "when to plant tomatoes, peppers, peas and lettuce in Denver",
        "growing degree days for corn in Des Moines, Iowa planted May 1",
        "Winkler index for Walla Walla, Washington",
        "frost dates for Christchurch, New Zealand",
        {
            "lat": 48.85,
            "lon": 2.35,
            "base": 10,
            "units": "metric",
            "start": "04-01"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("jumblemog/growing-season-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": [
        "frost dates for Minneapolis",
        "when to plant tomatoes, peppers, peas and lettuce in Denver",
        "growing degree days for corn in Des Moines, Iowa planted May 1",
        "Winkler index for Walla Walla, Washington",
        "frost dates for Christchurch, New Zealand",
        {
            "lat": 48.85,
            "lon": 2.35,
            "base": 10,
            "units": "metric",
            "start": "04-01",
        },
    ] }

# Run the Actor and wait for it to finish
run = client.actor("jumblemog/growing-season-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": [
    "frost dates for Minneapolis",
    "when to plant tomatoes, peppers, peas and lettuce in Denver",
    "growing degree days for corn in Des Moines, Iowa planted May 1",
    "Winkler index for Walla Walla, Washington",
    "frost dates for Christchurch, New Zealand",
    {
      "lat": 48.85,
      "lon": 2.35,
      "base": 10,
      "units": "metric",
      "start": "04-01"
    }
  ]
}' |
apify call jumblemog/growing-season-calculator --silent --output-dataset

```

## MCP server setup

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