Meteociel APImeteociel.fr ↗
Retrieve GFS weather forecasts from meteociel.fr for any city. Get 3-hourly and 6-hourly slots with temperature, precipitation, wind, and more.
What is the Meteociel API?
The Meteociel.fr API exposes 2 endpoints that cover city lookup and multi-day GFS weather forecasts for locations worldwide. Use search_cities to resolve a city name or French postal code to a numeric city_id, then pass that identifier to get_forecast to retrieve up to 10 calendar days of forecast data, sliced into 3-hourly slots for the near term and 6-hourly slots further out, with per-day aggregates including temp_min_c, temp_max_c, and precipitation_total_mm.
curl -X GET 'https://api.parse.bot/scraper/ebc58fcb-5e6b-45af-9c32-fb25025fac4b/search_cities?query=Valence' \ -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 meteociel-fr-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.
"""Walkthrough: Meteociel forecast SDK — search a city, fetch its forecast."""
from parse_apis.meteociel_fr_api import Meteociel, CityNotFound
client = Meteociel()
# Search for cities matching a name; limit caps total items yielded.
city = client.cities.search(query="Valence", limit=5).first()
if city is None:
raise SystemExit("No city found for that query")
print(f"{city.name} ({city.postal_code}, {city.country}) — id {city.city_id}")
# Fetch the 3-day GFS forecast for the discovered city.
try:
forecast = city.forecast(days=3)
except CityNotFound:
raise SystemExit(f"City {city.city_id} not found on the forecast endpoint")
print(f"Forecast {forecast.start_date} → {forecast.end_date}, "
f"model run: {forecast.model_run}, updated at {forecast.forecast_updated_at}")
# Walk each day and its hourly slots.
if forecast.days is not None:
for day in forecast.days:
print(f"\n {day.date} {day.temp_min_c}–{day.temp_max_c} °C "
f"rain {day.precipitation_total_mm} mm")
for slot in day.slots:
print(f" {slot.time} {slot.temperature_c} °C "
f"{slot.weather} wind {slot.wind_speed_kmh} km/h {slot.wind_direction}")
print("\nexercised: cities.search / city.forecast / ForecastDay / ForecastSlot")
Searches meteociel.fr's city index by name or French postal code and returns the matching cities with their numeric city_id, which get_forecast takes as input. French communes come first with their postal code; cities from other countries follow with postal_code null and country set to the site's French country label. One round trip. An unknown name returns an empty cities list (success).
| Param | Type | Description |
|---|---|---|
| queryrequired | string | City name (full or partial, e.g. one shape: Valence) or French postal code. |
{
"type": "object",
"fields": {
"query": "the search text as submitted",
"cities": "array of matching cities: city_id (string, input for get_forecast), name, slug (site URL slug), postal_code (string, French communes only, otherwise null), country (French label; 'France' for communes)"
},
"sample": {
"data": {
"query": "Valence",
"cities": [
{
"name": "Valence",
"slug": "valence",
"city_id": "4887",
"country": "France",
"postal_code": "16460"
},
{
"name": "Valence",
"slug": "valence",
"city_id": "8385",
"country": "France",
"postal_code": "26000"
},
{
"name": "Valence",
"slug": "valencia",
"city_id": "50851",
"country": "Espagne",
"postal_code": null
}
]
},
"status": "success"
}
}About the Meteociel API
City Search
search_cities accepts a query string — either a full or partial city name or a French postal code — and returns an array of matching cities. Each entry includes a city_id (the key input for get_forecast), a name, a URL slug, and a postal_code. French communes appear first with their postal code populated; international cities follow with postal_code set to null and a country field. This two-step lookup keeps the forecast endpoint clean: you resolve identifiers once and cache them.
GFS Forecast Data
get_forecast takes a city_id and an optional days parameter (1–10, today inclusive, dates expressed in the Europe/Paris timezone) and returns a structured forecast object. The top-level response includes city_name, postal_code, model_run (e.g. 'GFS de 0Z'), start_date, end_date, timezone, requested_days, and days_returned. The days array holds one entry per calendar date, each carrying temp_min_c, temp_max_c, precipitation_total_mm (summed from non-null slot values), and a slots array.
Forecast Slots
Each slot in the slots array represents one forecast interval with a datetime and a time field alongside per-interval meteorological values: temperature, feels-like temperature, precipitation, and wind data. Slots are 3-hourly for approximately the first three days of the window and switch to 6-hourly for days beyond that, mirroring the native GFS output resolution that meteociel.fr publishes. This means early-window slots are denser than later ones within the same response.
Coverage Notes
The forecast model is GFS only — the API reflects whatever GFS run meteociel.fr currently displays. Forecast depth is capped at 10 calendar days. French cities benefit from postal code enrichment in search results; non-French cities are searchable by name but return postal_code: null.
The Meteociel API is a managed, monitored endpoint for meteociel.fr — not a raw scraper you maintain. Every endpoint is automatically health-checked on a schedule, and when meteociel.fr 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 meteociel.fr 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 a 3-day hourly temperature and precipitation widget for French cities using
slotsdata fromget_forecast. - Build a trip-planning tool that resolves destination names via
search_citiesand fetches a 10-day outlook before travel. - Aggregate
precipitation_total_mmper day to alert field teams about wet conditions at specific job sites. - Compare
temp_min_c/temp_max_cacross multiple cities by batchingget_forecastcalls with differentcity_idvalues. - Power an agriculture scheduling dashboard with 6-hourly slot data for the 4–10 day window beyond the dense near-term period.
- Resolve French postal codes to city identifiers in bulk using
search_citiesto seed a location database.
| Tier | Price | Credits/month | Rate limit |
|---|---|---|---|
| Free | $0/mo | 200 | 5 req/min |
| Hobby | $30/mo | 1,000 | 20 req/min |
| Developer | $100/mo | 5,000 | 100 req/min |
| Team | $300/mo | 20,000 | 300 req/min |
| Company | $1,000/mo | 100,000 | 500 req/min |
Each endpoint has a fixed posted price per successful call — most fall between 1 and 10 credits — shown on this API's page before you run it. Exceeding the rate limit returns a 429 response. Authenticate with the X-API-Key header.
Does meteociel.fr offer an official developer API?+
What weather model does `get_forecast` use, and how far ahead does it go?+
get_forecast returns GFS (Global Forecast System) data, labeled in the response via the model_run field (e.g. 'GFS de 0Z'). The forecast window covers up to 10 calendar days starting from today in the Europe/Paris timezone. Slot resolution is 3-hourly for roughly the first three days and 6-hourly beyond that.Does the API return forecasts for non-French cities?+
search_cities returns international cities with a country field when postal_code is null. get_forecast works with any valid city_id regardless of country. However, postal code enrichment is only populated for French communes.Does the API cover historical weather data or other forecast models such as AROME or ECMWF?+
Are there any known limitations with city search results?+
city_id field is what get_forecast requires; the slug is provided for reference but is not an accepted input to any endpoint.