Scraping di dati meteo: fonti, API e implementazioni in vari linguaggi

Le previsioni del tempo sono uno di quei blocchi che aumentano il valore di un sito senza farsi notare: l’utente resta più a lungo sulla pagina, torna più spesso e il contenuto appare «vivo». Per questo i widget e i blocchi meteo sono così frequenti sui portali cittadini e turistici, nei servizi di prenotazione e sui siti di immobili all’estero. In questo articolo vediamo dove trovare i dati meteo, quali API sono popolari nel 2026, in che cosa il parsing dell’HTML si distingue dal lavoro tramite API, e mostriamo implementazioni pronte in Python, JavaScript, PHP e Go.

Che cos’è lo «scraping meteo» e quali approcci esistono

Sotto «scraping meteo» si raggruppano di solito due compiti di natura diversa:

1. Lavorare tramite un’API ufficiale. Il servizio restituisce dati strutturati (quasi sempre JSON): invii una richiesta HTTP e ricevi campi pronti — temperatura, umidità, velocità del vento, codice del fenomeno meteorologico. È la via affidabile, legale e prevedibile.
2. Scraping delle pagine HTML. Quando la fonte non offre un’API o l’API è a pagamento, gli sviluppatori estraggono i dati direttamente dal markup del sito. Funziona, ma è fragile: a ogni modifica dell’HTML lo scraper si rompe, e l’approccio stesso viola spesso le condizioni d’uso della fonte.

La conclusione pratica è semplice: ogni volta che esiste un’API, usa l’API. Lascia lo scraping ai casi in cui un’altra fonte davvero non c’è, e controlla sempre il robots.txt e le condizioni d’uso.

Fonti di dati e API popolari

Open-Meteo — gratuito e senza chiave

Open-Meteo è una delle opzioni più comode per iniziare. L’API non richiede una chiave per l’uso non commerciale, restituisce i dati in JSON e aggrega le previsioni dei servizi meteorologici nazionali con una risoluzione da 1 a 11 km. Per i progetti commerciali esistono piani a pagamento separati, con limiti mensili di richieste. Ideale per prototipi, widget e progetti open source.

OpenWeatherMap — il classico con un ampio limite gratuito

OpenWeatherMap resta il servizio più ripreso nei tutorial. Nel 2026 conserva una via gratuita funzionante, ma è importante capire quale prodotto esatto stai chiamando. Gli endpoint classici (meteo attuale, previsione a 3 ore, inquinamento dell’aria, mappe meteo, geocodifica) sono disponibili gratis con un limite di 60 richieste al minuto e fino a 1.000.000 di richieste al mese. I prodotti della famiglia One Call (3.0 / 4.0) sono abbonamenti a parte, con tariffazione a chiamata e le prime 1000 richieste al giorno gratuite. Prima di andare in produzione conviene impostare un tetto di spesa, per non superare per sbaglio la soglia gratuita.

WeatherAPI.com — un piano gratuito generoso

WeatherAPI.com fornisce il meteo attuale, la previsione oraria e giornaliera, dati storici, astronomia e geolocalizzazione, in JSON e XML. Una scelta comoda quando serve un unico provider «per tutto» con un limite gratuito chiaro.

Visual Crossing — dati storici solidi

Visual Crossing viene citato spesso tra i migliori per rapporto tra prezzo e possibilità: un’unica API per il meteo attuale, le previsioni, le allerte e soprattutto le lunghe serie storiche. Ci sono una chiave gratuita e un Query Builder per comporre le richieste con esportazione in JSON o CSV. Una buona opzione per analisi e dashboard.

Piattaforme per il business: Tomorrow.io, Weatherbit, Meteomatics, meteoblue

Se ti servono parametri molto specializzati (circa 500 per Tomorrow.io, oltre 1800 per Meteomatics, serie storiche dal 1940), guarda alle piattaforme corporate. Offrono alta precisione e un ventaglio enorme di parametri, ma quasi sempre richiedono un abbonamento a pagamento per l’uso commerciale.

Fonti italiane: MeteoAM, ARPA e portali meteo

• Servizio Meteorologico dell’Aeronautica Militare (MeteoAM). È il servizio meteorologico ufficiale dello Stato italiano: sul portale meteoam.it pubblica previsioni, osservazioni delle stazioni e bollettini, e rende disponibile una parte dei dati in formato aperto. Accanto a esso opera l’Agenzia nazionale ItaliaMeteo, il nuovo punto di riferimento civile per la meteorologia.
• ARPA regionali. Le agenzie regionali per la protezione dell’ambiente (ARPA Lombardia, ARPAE Emilia-Romagna e le altre) pubblicano osservazioni e serie meteorologiche come open data sui propri portali — utili per i progetti concentrati su un territorio specifico.
• Portali commerciali (ilMeteo.it, 3B Meteo). Offrono widget ufficiali da incorporare; per un’integrazione più profonda di norma servono un accordo con il servizio e il rispetto delle sue condizioni d’uso.

Servizi statali e ufficiali

Per gli Stati Uniti esiste l’API gratuita e senza chiave del servizio meteorologico nazionale (NWS, weather.gov) — una scelta eccellente per progetti civili e comunitari entro i confini del Paese. In Italia questo ruolo lo svolgono MeteoAM e le ARPA regionali descritti sopra, e altri servizi meteorologici nazionali europei mantengono portali di dati aperti simili. Le fonti statali sono gratuite e autorevoli, ma di solito limitate a un territorio specifico.

Confronto per criteri chiave

Implementazioni in vari linguaggi

In tutti gli esempi che seguono si usa Open-Meteo, perché non richiede una chiave: il codice si può eseguire subito. Le coordinate negli esempi corrispondono a Roma (41.90, 12.50). Per passare a un altro provider basta di solito cambiare l’URL, aggiungere la chiave e ritoccare il parsing del JSON.

Python (requests)

import requests

def get_weather(lat: float, lon: float) -> dict:
    url = "https://api.open-meteo.com/v1/forecast"
    params = {
        "latitude": lat,
        "longitude": lon,
        "current": "temperature_2m,relative_humidity_2m,wind_speed_10m,weather_code",
        "timezone": "auto",
    }
    response = requests.get(url, params=params, timeout=10)
    response.raise_for_status()
    return response.json()

data = get_weather(41.90, 12.50)
current = data["current"]
print(f"Temperatura: {current['temperature_2m']}°C")
print(f"Umidità: {current['relative_humidity_2m']}%")
print(f"Vento: {current['wind_speed_10m']} km/h")

Versione per OpenWeatherMap con chiave e localizzazione italiana:

import requests

API_KEY = "LA_TUA_CHIAVE"

def get_weather_owm(city: str) -> dict:
    url = "https://api.openweathermap.org/data/2.5/weather"
    params = {"q": city, "units": "metric", "lang": "it", "appid": API_KEY}
    response = requests.get(url, params=params, timeout=10)
    response.raise_for_status()
    d = response.json()
    return {
        "citta": d["name"],
        "temperatura": d["main"]["temp"],
        "percepita": d["main"]["feels_like"],
        "descrizione": d["weather"][0]["description"],
    }

print(get_weather_owm("Roma"))

JavaScript / Node.js (fetch nativo)

In Node.js 18+ fetch è disponibile di serie — non servono dipendenze esterne.

async function getWeather(lat, lon) {
  const url = new URL("https://api.open-meteo.com/v1/forecast");
  url.searchParams.set("latitude", lat);
  url.searchParams.set("longitude", lon);
  url.searchParams.set("current", "temperature_2m,wind_speed_10m,weather_code");
  url.searchParams.set("timezone", "auto");

  const response = await fetch(url);
  if (!response.ok) {
    throw new Error(`Errore HTTP: ${response.status}`);
  }
  return response.json();
}

getWeather(41.90, 12.50)
  .then((data) => {
    const c = data.current;
    console.log(`Temperatura: ${c.temperature_2m}°C, vento: ${c.wind_speed_10m} km/h`);
  })
  .catch((err) => console.error("Impossibile ottenere i dati meteo:", err.message));

PHP (cURL)

<?php
function getWeather(float $lat, float $lon): ?array
{
    $query = http_build_query([
        'latitude'  => $lat,
        'longitude' => $lon,
        'current'   => 'temperature_2m,wind_speed_10m,weather_code',
        'timezone'  => 'auto',
    ]);
    $url = "https://api.open-meteo.com/v1/forecast?{$query}";

    $ch = curl_init($url);
    curl_setopt_array($ch, [
        CURLOPT_RETURNTRANSFER => true,
        CURLOPT_TIMEOUT        => 10,
        CURLOPT_USERAGENT      => 'WeatherWidget/1.0',
    ]);
    $body = curl_exec($ch);
    $code = curl_getinfo($ch, CURLINFO_HTTP_CODE);
    curl_close($ch);

    if ($body === false || $code !== 200) {
        return null;
    }
    return json_decode($body, true);
}

$data = getWeather(41.90, 12.50);
if ($data !== null) {
    echo "Temperatura: " . $data['current']['temperature_2m'] . "°C\n";
}

Go

package main

import (
    "encoding/json"
    "fmt"
    "net/http"
    "time"
)

type WeatherResponse struct {
    Current struct {
        Temperature float64 `json:"temperature_2m"`
        WindSpeed   float64 `json:"wind_speed_10m"`
        WeatherCode int     `json:"weather_code"`
    } `json:"current"`
}

func main() {
    url := "https://api.open-meteo.com/v1/forecast" +
        "?latitude=41.90&longitude=12.50" +
        "&current=temperature_2m,wind_speed_10m,weather_code&timezone=auto"

    client := &http.Client{Timeout: 10 * time.Second}
    resp, err := client.Get(url)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    var data WeatherResponse
    if err := json.NewDecoder(resp.Body).Decode(&data); err != nil {
        panic(err)
    }
    fmt.Printf("Temperatura: %.1f°C, vento: %.1f km/h\n",
        data.Current.Temperature, data.Current.WindSpeed)
}

Richiesta all’API di OpenWeatherMap (cURL)

curl "https://api.openweathermap.org/data/2.5/weather?q=Roma,IT&units=metric&lang=it&appid=LA_TUA_CHIAVE"

È lo stesso endpoint dell’esempio Python qui sopra, comodo per un test rapido dal terminale: il parametro lang=it restituisce le descrizioni dei fenomeni in italiano.

Scraping dell’HTML come piano di riserva (Python + BeautifulSoup)

Quando l’API non è disponibile, i dati si possono estrarre dal markup. L’approccio funziona, ma è fragile: se l’HTML cambia, i selettori smettono di funzionare, ed è ammissibile solo se non contraddice le condizioni della fonte.

import requests
from bs4 import BeautifulSoup

def scrape_weather(url: str) -> str:
    headers = {"User-Agent": "Mozilla/5.0"}
    html = requests.get(url, headers=headers, timeout=10).text
    soup = BeautifulSoup(html, "html.parser")
    # Il selettore va adattato alla pagina di origine specifica
    temp = soup.select_one(".temperature")
    return temp.get_text(strip=True) if temp else "non trovato"

La decodifica del weather_code in Open-Meteo segue lo standard WMO: per esempio, 0 — sereno, 2 — parzialmente nuvoloso, 61 — pioggia debole, 71 — neve debole. Tieni la tabella completa dei codici in un dizionario di mapping, per mostrare all’utente una descrizione leggibile.

Cache, limiti e aspetti legali

Alcune regole che in produzione fanno risparmiare soldi e nervi:

• Metti in cache le risposte. Il meteo non deve quasi mai aggiornarsi a ogni visualizzazione di pagina. Fai cache per coordinate, città o CAP, e aggiorna le condizioni attuali ogni 5–15 minuti. Per le app mobili instrada le richieste attraverso il tuo backend, non direttamente da ogni client.
• Tieni le chiavi sul server. La chiave API non va incorporata nel codice client: è facile rubarla. Le richieste devono passare dal tuo proxy di backend.
• Sorveglia i limiti. Configura la gestione delle risposte 401 (chiave errata) e 429 (limite superato) e gli alert su una crescita brusca del numero di chiamate.
• Controlla la licenza. La maggior parte dei piani gratuiti consente solo l’uso non commerciale. Alcuni servizi (Visual Crossing, OpenWeatherMap) ammettono un uso commerciale limitato citando la fonte. Per lo scraping verifica sempre il robots.txt e le condizioni d’uso.

Dove si usa: portali, turismo e immobiliare

Il blocco meteo è la classica marcia in più dei progetti legati alla geografia e allo stile di vita dell’utente:

• I portali cittadini mostrano il meteo attuale e le previsioni in homepage: trattengono il pubblico e rendono il sito un punto d’ingresso quotidiano.
• I portali turistici e i servizi di prenotazione aggiungono il meteo alla scheda della destinazione: per chi viaggia è importante sapere che cosa lo aspetta all’arrivo.
• I siti di immobili all’estero usano il meteo come parte della «vendita del clima»: giornate di sole, inverni miti e temperature piacevoli sono un argomento di peso nella scelta di una casa al mare o in montagna.

La cosa curiosa è che, sul piano tecnico, lo scraping meteo appartiene alla stessa famiglia di un altro compito tipico di questi progetti: la raccolta e l’aggregazione di annunci. Se il meteo rende «viva» la scheda della destinazione, a riempire il catalogo degli immobili pensa lo scraping immobiliare: raccolta automatica delle offerte dai portali di origine, normalizzazione di prezzi e caratteristiche, aggiornamento del database. Spesso i due moduli lavorano fianco a fianco: uno si occupa del contenuto dell’immobile, l’altro del contesto che lo circonda.

Conclusione

Per la maggior parte dei compiti conviene partire da Open-Meteo (avvio immediato, senza chiave) o da OpenWeatherMap (ampio limite gratuito ed ecosistema maturo). Se contano i dati storici, guarda a Visual Crossing; se il progetto è concentrato sull’Italia, punta alle fonti ufficiali come MeteoAM e le ARPA regionali. Sul piano tecnico l’integrazione occupa poche righe in qualsiasi linguaggio: richiesta HTTP, parsing del JSON, cache. E un blocco meteo ben integrato aumenta sensibilmente il coinvolgimento su portali cittadini, turistici e immobiliari — lì dove all’utente non interessa solo l’oggetto in sé, ma anche il contesto che lo circonda.