Dendrology · Archives · Importing from APIs

Every machine learning model in this archive is hungry for the same thing: data. Before an algorithm can find patterns in the weather, someone has to get the weather into a table — and the fastest way to do that is an API, a web service that hands you forecasts and observations on request. This entry covers what a weather API is, how to pull a real forecast with a few lines of Python, and the ground rules (keys, rate limits, terms) that keep you a welcome guest.

The Restaurant Model: Why You Order Instead of Cook

Producing weather data from scratch means running the kitchen yourself: satellite feeds, station networks, and numerical models that demand supercomputer time. An API lets you skip all of that and order off a menu instead.

The menu is the documentation. It lists every dish the kitchen can make — hourly temperature, precipitation, wind, soil moisture — and how to ask for each one.
Your order is the request. A single URL with parameters spelling out the location, the variables, and the time span you want. No ambiguity: the kitchen makes exactly what the ticket says.
The dish is the response. Structured data, almost always JSON — a text format your code can parse in one line.
The house rules are the terms of service. Some restaurants seat anyone; others require a reservation (an API key) and will stop serving a table that orders five hundred plates a minute (rate limits).

The restaurant does the expensive work once and serves thousands of customers. That economy of scale is why even large forecasting operations source much of their raw data through APIs rather than running their own instruments.

Placing a First Order: Open-Meteo

Open-Meteo is an ideal first kitchen: its forecast API is free for non-commercial use with no API key required. A request is one URL — https://api.open-meteo.com/v1/forecast — plus parameters. The required ones are latitude and longitude (WGS84 coordinates); hourly takes a comma-separated list of variables such as temperature_2m,precipitation; forecast_days accepts 0–16 (default 7).

Here is a complete, runnable example using Python’s Requests library:

import requests

params = {
    "latitude": 52.52,      # Berlin — swap in your own coordinates
    "longitude": 13.41,
    "hourly": "temperature_2m,precipitation",
    "forecast_days": 2,
}
resp = requests.get("https://api.open-meteo.com/v1/forecast",
                    params=params, timeout=30)
resp.raise_for_status()     # stop early if the kitchen sends back an error
data = resp.json()

unit = data["hourly_units"]["temperature_2m"]
for time, temp in zip(data["hourly"]["time"][:6],
                      data["hourly"]["temperature_2m"][:6]):
    print(f"{time}  {temp} {unit}")

The response is JSON with an hourly object holding parallel arrays — one of ISO 8601 timestamps, one per requested variable — plus an hourly_units object naming the units (°C, mm). The loop above prints the next six hours of temperatures.

Three menu details worth knowing from the start: timestamps arrive in GMT unless you send a timezone parameter; daily aggregations (a daily parameter instead of hourly) require that timezone parameter; and units default to metric, with options like temperature_unit=fahrenheit and precipitation_unit=inch if you need them. A past_days parameter (up to 92) even lets you reach back for recent history in the same call.

The Government Kitchen: NOAA’s National Weather Service API

For United States coverage, the official alternative is the National Weather Service API at api.weather.gov — the forecasts, observations, and alerts produced by the US government’s own forecasters. It is also free and keyless, but with a different house rule: every request must carry a User-Agent header identifying your application (ideally with contact information), so NWS can reach you if something goes wrong. Its rate limits are not published, but the documentation describes them as generous for typical use, and a blocked request can usually be retried within about five seconds.

House Rules: Keys, Rate Limits, and Terms

Wherever you order from, three rules keep you seated:

Keys and identification. Many commercial APIs issue a key — a password proving the order is yours. Open-Meteo reserves keys for commercial customers; NWS asks for a User-Agent instead. Treat keys like passwords: never commit them to a public repository.
Rate limits. Every provider caps how fast one client may order. Be polite by design: cache responses instead of re-requesting an unchanged forecast, and back off when you receive an error.
Terms of service. “Free” usually means free for a purpose — non-commercial use, attribution, or both. Read the menu’s fine print before building on it.

In Action at Dendrology

Feeding the pattern finders. The genetic and heuristic algorithm entries assume tables of weather variables to learn from. API imports are designed to be the first stage of that pipeline: request, parse, tabulate, train.
Irrigation timing. The irrigation rigging entry shows how precipitation forecasts let growers skip watering ahead of predicted rain. Those forecasts enter the system exactly as above — an hourly precipitation array, ordered on schedule.
From order to pantry. A forecast is perishable; yesterday’s becomes today’s training data only if you save it. Pair this entry with Writing CSV Files, where API responses are preserved as the historical archive Dendrology’s models are designed to learn from.

Beyond the Basics

Ready to go past the first order?

Client libraries. Requests handles any HTTP API; many providers also publish purpose-built Python clients that manage parsing and caching for you.
Authentication schemes. Commercial weather APIs use keys, tokens, and OAuth — worth learning before you outgrow the free tiers.
Scheduled ingestion. A forecast fetched once is a snapshot; a fetch that runs every morning is a dataset. Task schedulers turn the former into the latter.
Historical archives. Open-Meteo also serves decades of reconstructed past weather through a separate historical API — covered in the Writing CSV Files entry.

An API turns the hardest part of weather data science — getting the data — into a single well-formed request. Master the menu, and Dendrology’s entire forecasting toolkit is one order away.

Importing from APIs: Ordering Weather Data off the Menu