meteo APImeteo.pl ↗
Access ICM UW weather forecasts via API. Get hourly temperature, wind, pressure, and precipitation from UM and GFS models for any location.
What is the meteo API?
The meteo.pl API provides 3 endpoints to access detailed numerical weather forecasts from Poland's Interdisciplinary Centre for Mathematical and Computational Modelling (ICM UW). The get_forecast endpoint returns hourly time-series data covering temperature, sea-level pressure, wind, precipitation, and cloud parameters for any coordinates, driven by the UM (4 km resolution, Central Europe) and GFS (global) forecast models.
curl -X GET 'https://api.parse.bot/scraper/42cc9553-a71b-4a4e-820c-56bbd6760c9d/search_location?query=Warsaw' \ -H 'X-API-Key: $PARSE_API_KEY'
Typed, relational, agent-ready
A generated client with real types, enums, and the links between objects — the structure a flat JSON response can't carry. Autocompletes in your editor and reads cleanly to coding agents.
- Fully typed · autocompletes
- Objects link to objects
- Typed errors & pagination
Typed Python client. Set up the SDK in your uv project, then pull this API’s typed client:
uv add parse-sdk uv run parse init uv run parse add --marketplace meteo-pl-api
uv run parse add --marketplace pulls a pinned snapshot of this canonical API — it won’t change underneath you. To customize it, subscribe and swap to your own copy.
from parse_apis.meteo_pl_weather_api import Meteo, ForecastModel, Location, Forecast
meteo = Meteo()
# Search for locations matching "Krakow"
for loc in meteo.locations.search(query="Krakow"):
print(loc.display_name, loc.lat, loc.lon)
# Get available forecast model runs
avail = meteo.modelavailabilities.get()
print(avail.um4_60, avail.gfs)
# Fetch a detailed forecast for Warsaw using UM 4km/60h model
forecast = meteo.forecasts.get(location="Warsaw", model=ForecastModel.UM4_60)
print(forecast.metadata.model, forecast.metadata.run_timestamp)
print(forecast.location.display_name, forecast.location.lat, forecast.location.lon)
for entry in forecast.forecast:
print(entry.date_time, entry.airtmp_point, entry.pcpttl_aver, entry.cldtot_aver)
Search for a location by name to get coordinates, display name, and address details. Returns up to 5 matching results from the geocoding service. Each result includes latitude, longitude, display_name, address components, and OpenStreetMap metadata. Use to resolve a city name into coordinates for get_forecast.
| Param | Type | Description |
|---|---|---|
| queryrequired | string | City name or location query (e.g. 'Warsaw', 'Krakow'). |
{
"type": "object",
"fields": {
"results": "array of location objects with lat, lon, display_name, address, and OpenStreetMap metadata"
},
"sample": {
"data": {
"results": [
{
"lat": "52.2319581",
"lon": "21.0067249",
"type": "city",
"class": "place",
"osm_id": 336075,
"address": {
"city": "Warszawa",
"state": "mazowieckie",
"country": "Polska",
"country_code": "pl"
},
"licence": "Data OpenStreetMap contributors, ODbL 1.0.",
"osm_type": "relation",
"place_id": 767705185,
"importance": 0,
"display_name": "Warszawa, mazowieckie, Polska"
}
]
},
"status": "success"
}
}About the meteo API
Location Search and Geocoding
Before fetching a forecast, use search_location with a query parameter (city name or address string) to resolve a place to coordinates. The endpoint returns up to 5 candidate results, each containing lat, lon, display_name, and a structured address object with OpenStreetMap metadata. Pass the resolved lat and lon directly to get_forecast, or supply a location string and let the API geocode it internally.
Forecast Models and Run Timestamps
get_available_forecasts returns the timestamps of available model runs as Unix epoch integers, grouped by model key: gfs (global), um4_60 (UM 4 km, 60-hour horizon for Central Europe), and um4_120 (UM 4 km, 120-hour horizon). Use these timestamps to pass a specific date parameter to get_forecast, or omit date to default to the latest available run. The model choice affects both spatial resolution and forecast horizon.
Hourly Forecast Data
get_forecast accepts lat/lon or a location name, an optional model string (um4_60, um4_120, or gfs), and an optional Unix date for the desired model run. The response contains a forecast array of hourly entries keyed by date_time, with meteorological fields including airtmp_point (air temperature), slpres_point (sea-level pressure), wind10_sd_true_prev_poi (10 m wind), and precipitation and cloud coverage fields. The location object in the response confirms the resolved lat, lon, and display_name. The metadata object records the model name, run_timestamp, and forecast_start.
Coverage Notes
The UM model covers Central Europe at 4 km resolution with either a 60-hour or 120-hour lookahead depending on the selected variant. The GFS model covers global coordinates but at coarser resolution. Both models are produced by ICM UW at the University of Warsaw and are updated on a regular run schedule reflected in the timestamps returned by get_available_forecasts.
The meteo API is a managed, monitored endpoint for meteo.pl — not a raw scraper you maintain. Every endpoint is automatically health-checked on a schedule, and when meteo.pl changes and a check fails, the API is automatically queued for repair and re-verified. It is built to keep working as the site underneath it changes.
This isn't an official meteo.pl API — it's an independent, maintained REST wrapper over public data. Where the source has no official API (or only a limited one), Parse gives you a stable contract over a source that never promised one, and keeps it current. Need a new endpoint or field? You can revise it yourself in plain English and the agent rebuilds it against the live site in minutes — contributing the change back to the shared API is free.
Will this API break when the source site changes?+
Is this an official API from the source site?+
Can I fix or extend this API myself if I need a new endpoint or field?+
What happens if I call an endpoint that has an issue?+
- Display hourly temperature and wind forecasts for Polish cities in a travel or event planning app using
get_forecastwith UM 4 km resolution. - Monitor sea-level pressure trends at specific coordinates for agricultural scheduling by parsing the
slpres_pointfield in the forecast time series. - Build a Central European weather dashboard that surfaces the latest available UM and GFS run times via
get_available_forecasts. - Geocode user-entered city names to coordinates with
search_locationbefore feeding them into downstream forecast requests. - Compare 60-hour and 120-hour UM model outputs for the same location by calling
get_forecasttwice with differentmodelvalues. - Trigger weather-based logistics alerts when precipitation fields in the hourly forecast exceed operational thresholds.
- Archive historical model run data by recording the
run_timestampand full forecast arrays from successiveget_forecastcalls.
| Tier | Price | Credits/month | Rate limit |
|---|---|---|---|
| Free | $0/mo | 100 | 5 req/min |
| Hobby | $30/mo | 1,000 | 20 req/min |
| Developer | $100/mo | 5,000 | 100 req/min |
One credit = one API call regardless of which marketplace API you call. Exceeding the rate limit returns a 429 response. Authenticate with the X-API-Key header.
Does meteo.pl provide an official developer API?+
What meteorological fields does `get_forecast` actually return?+
forecast array includes date_time, air temperature (airtmp_point), sea-level pressure (slpres_point), 10 m wind speed and direction (wind10_sd_true_prev_poi), and precipitation and cloud coverage parameters. The metadata object records which model was used, its run_timestamp, and the forecast_start time.Does the UM model cover locations outside Central Europe?+
um4_60 and um4_120 models are limited to Central Europe. For locations outside that region, the gfs model covers global coordinates at coarser resolution. If you request a UM forecast for a point outside its grid, the API auto-selects a model, or you can explicitly pass model: 'gfs'.