API Open-Meteo no Python e no Power BI: fuso, listas e erros

1 Faça a primeira chamada

curl -s "https://api.open-meteo.com/v1/forecast?latitude=-23.55&longitude=-46.63&current=temperature_2m,weather_code&hourly=temperature_2m,precipitation_probability&daily=temperature_2m_max,temperature_2m_min,precipitation_sum&timezone=America%2FSao_Paulo&forecast_days=3"

A resposta, resumida (consulta de 07/11/2026):

{"latitude":-23.514938,"longitude":-46.610504,"utc_offset_seconds":-10800,
 "timezone":"America/Sao_Paulo","elevation":737.0,
 "current":{"time":"2026-11-07T21:15","interval":900,"temperature_2m":22.7,"weather_code":3},
 "hourly":{"time":["2026-11-07T00:00","2026-11-07T01:00", "..."],"temperature_2m":["..."],"precipitation_probability":["..."]},
 "daily":{"time":["2026-11-07","2026-11-08","2026-11-09"],
          "temperature_2m_max":[30.1,21.2,16.2],"temperature_2m_min":[19.2,14.0,12.8],"precipitation_sum":[6.2,7.8,0.7]}}

Quatro coisas para guardar:

• Os horários não trazem fuso ("2026-11-07T21:15"). O fuso vem à parte, em utc_offset_seconds (aqui, -10800, ou seja, UTC-3).
• A latitude e a longitude devolvidas não são as que você pediu. Pedi -23.55, -46.63 e voltou -23.514938, -46.610504: a API escolhe a célula da grade do modelo meteorológico. Não use esse par como a coordenada da cidade.
• current tem interval: 900: o valor "atual" muda a cada 15 minutos.
• O weather_code é um número (código WMO): 3 é "nublado". O texto fica por sua conta, e o passo 4 mostra como.

2 Acerte o fuso horário

Aqui está o problema da abertura. Sem o parâmetro timezone, a API usa GMT. Na consulta de 07/11/2026, às 21:15 em São Paulo, current.time voltou como 2026-11-08T00:15: já era o dia 8. E o primeiro dia da lista daily foi 2026-11-08, quando com timezone=America/Sao_Paulo foi 2026-11-07.

Você tem duas saídas:

• Um fuso fixo, no formato da base IANA: timezone=America/Sao_Paulo.
• timezone=auto, que descobre o fuso pelas coordenadas.

A diferença aparece fora de Brasília. Em Manaus, com timezone=America/Sao_Paulo o current.time foi 21:15; com auto, 20:15, que é a hora local de Manaus (UTC-4).

3 Várias cidades numa chamada só

Separe as coordenadas por vírgula, e a API devolve uma previsão por cidade. Com timezone=auto, cada cidade recebe o seu fuso. Este bloco e o do próximo passo formam um script só, executado em 08/11/2026:

import gzip, json, time, urllib.error, urllib.parse, urllib.request
from datetime import date, datetime, timedelta, timezone

BASE = "https://api.open-meteo.com/v1/forecast"

def baixar(url, tentativas=3):
    """Devolve o JSON. O erro 400 da Open-Meteo vira uma exceção com o motivo."""
    for n in range(1, tentativas + 1):
        try:
            with urllib.request.urlopen(url, timeout=30) as r:
                status, corpo, enc = r.status, r.read(), r.headers.get("Content-Encoding")
        except urllib.error.HTTPError as e:
            status, corpo, enc = e.code, e.read(), e.headers.get("Content-Encoding")
            if status in (502, 503, 504) and n < tentativas:
                time.sleep(3 * n)
                continue
        if enc == "gzip":
            corpo = gzip.decompress(corpo)
        if not corpo:                              # sem latitude e longitude, a API responde 200 e corpo vazio
            raise RuntimeError(f"Open-Meteo respondeu {status} com o corpo vazio")
        j = json.loads(corpo)
        if status == 400:
            raise RuntimeError(f"Open-Meteo respondeu 400: {j['reason']}")
        return j

def previsao(cidades, dias=3):
    nomes = [c[0] for c in cidades]
    params = {
        "latitude": ",".join(str(c[1]) for c in cidades),
        "longitude": ",".join(str(c[2]) for c in cidades),
        "current": "temperature_2m,weather_code",
        "hourly": "precipitation_probability",
        "daily": "temperature_2m_max,temperature_2m_min,precipitation_sum,weather_code",
        "timezone": "auto",                        # um fuso por cidade (Manaus não é Brasília)
        "forecast_days": dias,
    }
    j = baixar(f"{BASE}?{urllib.parse.urlencode(params, safe=',')}")
    lista = j if isinstance(j, list) else [j]      # uma cidade = objeto; várias = lista
    return list(zip(nomes, lista))

CIDADES = [("São Paulo", -23.55, -46.63), ("Manaus", -3.12, -60.02), ("Recife", -8.05, -34.88),
           ("Porto Alegre", -30.03, -51.23), ("Brasília", -15.78, -47.93)]

for nome, j in previsao(CIDADES):
    fuso = timezone(timedelta(seconds=j["utc_offset_seconds"]))
    agora = datetime.fromisoformat(j["current"]["time"]).replace(tzinfo=fuso)
    d = j["daily"]
    hoje = {k: v[0] for k, v in d.items()}          # as listas são paralelas: o índice 0 é o dia 0
    print(f'{nome:<13} {j["timezone"]:<18} agora {agora:%H:%M} | hoje {hoje["temperature_2m_min"]:.0f}-{hoje["temperature_2m_max"]:.0f}°C, '
          f'{hoje["precipitation_sum"]:.1f} mm, código {hoje["weather_code"]}')

São Paulo     America/Sao_Paulo  agora 21:15 | hoje 19-30°C, 6.2 mm, código 95
Manaus        America/Manaus     agora 20:15 | hoje 27-34°C, 0.8 mm, código 51
Recife        America/Recife     agora 21:15 | hoje 26-31°C, 1.0 mm, código 51
Porto Alegre  America/Sao_Paulo  agora 21:15 | hoje 16-22°C, 13.8 mm, código 80
Brasília      America/Sao_Paulo  agora 21:15 | hoje 20-30°C, 4.5 mm, código 55

Por que assim:

• Uma cidade volta como objeto, várias voltam como lista. O lista = j if isinstance(j, list) else [j] cobre os dois casos. Sem ele, o código funciona com 5 cidades e quebra no dia em que você consultar uma só.
• timezone=auto deu um fuso por cidade: Manaus saiu 1 hora atrás das outras, como deveria.
• urlencode(..., safe=',') mantém as vírgulas na URL, em vez de trocá-las por %2C.
• O utc_offset_seconds vira um fuso com timezone(timedelta(seconds=...)), e assim o horário da API ganha o fuso que ele não traz.
• O baixar trata o 400 e o corpo vazio, que aparecem em Erros comuns, e repete a chamada só nos erros 502, 503 e 504.

4 Das listas paralelas às linhas

Uma lista por variável é ótima para gráfico, mas, para uma tabela, você quer uma linha por dia. Como as listas têm o mesmo tamanho, basta juntá-las pela posição. O mesmo vale para o texto do código WMO:

WMO = {0: "céu limpo", 1: "predominantemente limpo", 2: "parcialmente nublado", 3: "nublado", 45: "nevoeiro",
       48: "nevoeiro com geada", 51: "garoa fraca", 53: "garoa moderada", 55: "garoa intensa",
       61: "chuva fraca", 63: "chuva moderada", 65: "chuva forte", 80: "pancadas de chuva fracas",
       81: "pancadas de chuva moderadas", 82: "pancadas de chuva violentas", 95: "trovoada",
       96: "trovoada com granizo fraco", 99: "trovoada com granizo forte"}

url = (BASE + "?latitude=-23.55&longitude=-46.63&hourly=precipitation_probability"
       "&daily=temperature_2m_max,temperature_2m_min,precipitation_sum,weather_code&timezone=auto&forecast_days=3")
j = baixar(url)
d = j["daily"]
linhas = [dict(zip(d.keys(), valores)) for valores in zip(*d.values())]   # listas paralelas -> uma linha por dia
for l in linhas:
    dia = date.fromisoformat(l["time"])
    print(f'{dia:%d/%m} {l["temperature_2m_min"]:.0f}-{l["temperature_2m_max"]:.0f}°C {l["precipitation_sum"]:.1f} mm  {WMO.get(l["weather_code"], "código " + str(l["weather_code"]))}')

fuso = timezone(timedelta(seconds=j["utc_offset_seconds"]))
agora = datetime(2026, 11, 7, 21, 0, tzinfo=fuso)
h = j["hourly"]
horas = [(datetime.fromisoformat(t).replace(tzinfo=fuso), p) for t, p in zip(h["time"], h["precipitation_probability"])]
prox = next(((t, p) for t, p in horas if t >= agora and p >= 50), None)
print("próxima hora com chuva >= 50%:", f"{prox[0]:%d/%m %H:%M} ({prox[1]}%)" if prox else "nenhuma")

07/11 19-30°C 6.2 mm  trovoada
08/11 14-21°C 7.8 mm  pancadas de chuva fracas
09/11 13-16°C 0.7 mm  garoa fraca
próxima hora com chuva >= 50%: 07/11 23:00 (61%)

Duas observações:

• O zip(*d.values()) pega a posição 0 de todas as listas, depois a posição 1, e assim por diante. O dict(zip(d.keys(), ...)) devolve cada dia como um registro com o nome das variáveis.
• O "agora" está fixo em 07/11/2026 às 21:00 só para o resultado ser reproduzível. No seu código, use datetime.now(fuso).
• A tradução dos códigos WMO é minha. A documentação traz a tabela em inglês e a API devolve só o número. O dicionário cobre os códigos mais comuns, e o WMO.get(...) mostra "código N" para os outros.

5 Power Query: do JSON às colunas

Conforme a documentação oficial do Web.Contents (link nas referências); não executado aqui. Teste no seu Power BI Desktop antes de publicar.

let
    Fonte = Json.Document(Web.Contents("https://api.open-meteo.com", [
        RelativePath = "v1/forecast",
        Query = [
            latitude = "-23.55",
            longitude = "-46.63",
            daily = "temperature_2m_max,temperature_2m_min,precipitation_sum,weather_code",
            timezone = "auto",
            forecast_days = "7"
        ]
    ])),
    Diario = Fonte[daily],
    Tabela = Table.FromColumns(
        {Diario[time], Diario[temperature_2m_max], Diario[temperature_2m_min], Diario[precipitation_sum], Diario[weather_code]},
        {"Data", "Maxima", "Minima", "ChuvaMm", "CodigoTempo"}),
    Tipada = Table.TransformColumnTypes(Tabela,
        {{"Data", type date}, {"Maxima", type number}, {"Minima", type number},
         {"ChuvaMm", type number}, {"CodigoTempo", Int64.Type}}, "en-US")
in
    Tipada

Por que montar assim:

• Table.FromColumns recebe uma lista de listas, e as listas paralelas da API encaixam direto. Cada lista vira uma coluna, sem laço.
• RelativePath e Query em vez de concatenar a URL. O serviço do Power BI não atualiza fonte dinâmica, aquela cuja URL só se conhece quando a consulta roda. Com a base fixa no primeiro argumento do Web.Contents, a atualização agendada funciona.
• "en-US" na conversão de tipos garante a leitura de 2026-11-07 e dos números com ponto decimal.
• timezone = "auto" pelo mesmo motivo do passo 2: sem ele, o Data do Power BI vem em GMT.

A API também entrega CSV com format=csv. Fica mais fácil de ler, mas tem uma pegadinha: antes da tabela vêm duas linhas de metadados e uma linha em branco, e o nome de cada coluna carrega a unidade entre parênteses (temperature_2m_max (°C)). Esta consulta, também não executada, pula as três linhas:

let
    Bruto = Csv.Document(Web.Contents("https://api.open-meteo.com", [
        RelativePath = "v1/forecast",
        Query = [latitude = "-23.55", longitude = "-46.63",
                 daily = "temperature_2m_max,temperature_2m_min,precipitation_sum",
                 timezone = "auto", forecast_days = "7", format = "csv"]
    ]), [Delimiter = ",", Encoding = 65001]),
    Tabela = Table.PromoteHeaders(Table.Skip(Bruto, 3), [PromoteAllScalars = true])
in
    Tabela

A estrutura do CSV (os metadados, a linha em branco e o cabeçalho com unidades) eu confirmei com uma chamada real. O que não pude testar é como o Csv.Document trata a linha em branco; se ela não contar como linha, ajuste o Table.Skip para 2.