# Weather Forecast Scraper — Global, by Place or Coordinates (`hipersoft/open-meteo-weather-scraper`) Actor

Fetch global weather forecasts and recent history for any place name or coordinates. Get hourly and daily temperature, precipitation, wind and more as structured JSON, CSV or Excel — for apps, dashboards, research and n8n.

- **URL**: https://apify.com/hipersoft/open-meteo-weather-scraper.md
- **Developed by:** [hiper soft](https://apify.com/hipersoft) (community)
- **Categories:** Other, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.0005 / forecast scraped

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Weather Forecast Scraper — Global Forecasts & History by Place or Coordinates

Get **global weather forecasts and recent history** for any location as clean, structured **JSON, CSV, Excel or XML**. Look up locations by **place name** (Singapore, London, New York) or by exact **latitude/longitude**, and pull **hourly and daily** series — temperature, precipitation, wind, humidity, cloud cover and more. One run, one tidy row per location, ready for apps, dashboards, research and automation.

### What does the Weather Forecast Scraper do?

This actor turns weather data into a structured dataset. Give it a list of place names or coordinates, choose the hourly and daily variables you care about, and it returns a flat record per location: resolved coordinates, timezone, elevation and the full forecast series for the days you requested. Add past days to include recent history alongside the forecast. Export the results in any format the Apify platform supports, or fetch them straight through the API.

### What data can you get?

| Data point | Description |
| --- | --- |
| Location name & query | The place label and the original search term. |
| Resolved coordinates | Latitude and longitude used for the forecast. |
| Country & region | Country and first-level region for geocoded places. |
| Elevation | Ground elevation in metres. |
| Timezone | IANA timezone, abbreviation and UTC offset. |
| Hourly series | Requested hourly variables (e.g. temperature, precipitation, wind) with timestamps. |
| Daily series | Optional daily aggregates (e.g. max/min temperature, precipitation sum). |
| Units | Unit for every returned variable. |
| Coverage window | Number of hours/days plus first and last timestamp. |

### Use cases

- **Live dashboards** — power a weather widget or operations dashboard for many cities at once.
- **Forecast pipelines** — feed structured temperature, rain and wind series into BI tools and models.
- **Location monitoring** — track conditions across stores, sites, farms or delivery zones.
- **Trip & event planning** — pull multi-day forecasts for a batch of destinations.
- **Research datasets** — combine forecast and recent-history data for analysis.

### How to use the Weather Forecast Scraper

1. Add the actor to your Apify account and open its input.
2. Enter **places** (one name per line) and/or exact **locations** as `{ "latitude": ..., "longitude": ... }` objects.
3. Choose the **hourly** variables (and optional **daily** ones), set **forecastDays**, a **timezone**, and optional **pastDays**.
4. Click **Run**.
5. Export the results as JSON, CSV, Excel or XML, or fetch them through the Apify API.

### Input

```json
{
  "places": ["Singapore", "London"],
  "locations": [{ "name": "HQ", "latitude": 1.29, "longitude": 103.85 }],
  "hourly": ["temperature_2m", "precipitation", "windspeed_10m"],
  "daily": ["temperature_2m_max", "temperature_2m_min", "precipitation_sum"],
  "forecastDays": 7,
  "timezone": "auto",
  "pastDays": 0
}
```

| Field | Description |
| --- | --- |
| `places` | Place names to resolve to coordinates, one per line. |
| `locations` | Exact coordinates as objects with `latitude`, `longitude` and an optional `name`. |
| `hourly` | Hourly variables to include (defaults to temperature, precipitation, wind speed). |
| `daily` | Optional daily aggregate variables. |
| `forecastDays` | Days of forecast from today forward (1–16). |
| `timezone` | `auto` for each location's local time, or an IANA name like `Asia/Singapore`. |
| `pastDays` | Days of recent past weather to include before today (0–92). |
| `proxyConfiguration` | Standard Apify proxy settings for the run (optional). |

### What you get

One record per location, ready to export to JSON, CSV, Excel or XML.

```json
{
  "name": "Singapore",
  "query": "Singapore",
  "latitude": 1.3,
  "longitude": 103.86,
  "country": "Singapore",
  "admin1": null,
  "elevation": 27,
  "timezone": "Asia/Singapore",
  "timezoneAbbreviation": "GMT+8",
  "utcOffsetSeconds": 28800,
  "forecastDays": 3,
  "pastDays": 0,
  "hourlyVariables": "temperature_2m,precipitation,windspeed_10m",
  "dailyVariables": null,
  "hours": 72,
  "days": 0,
  "startTime": "2026-08-31T00:00",
  "endTime": "2026-09-02T23:00",
  "hourlyUnits": { "temperature_2m": "°C", "precipitation": "mm", "windspeed_10m": "km/h" },
  "hourly": {
    "time": ["2026-08-31T00:00", "2026-08-31T01:00"],
    "temperature_2m": [27.4, 27.1],
    "precipitation": [0.0, 0.2],
    "windspeed_10m": [6.1, 5.4]
  },
  "dailyUnits": null,
  "daily": null,
  "scrapedAt": "2026-08-31T09:15:04.123Z"
}
```

#### Output schema

| Field | Type | Description |
| --- | --- | --- |
| `name` | string | Location label (geocoded name or the coordinate's given name). |
| `query` | string | Original place search term, when applicable. |
| `latitude` | number | Latitude used for the forecast. |
| `longitude` | number | Longitude used for the forecast. |
| `country` | string | Country of a geocoded place. |
| `admin1` | string | First-level region (state/province) of a geocoded place. |
| `elevation` | number | Ground elevation in metres. |
| `timezone` | string | IANA timezone of the returned timestamps. |
| `timezoneAbbreviation` | string | Short timezone label (e.g. `GMT+8`). |
| `utcOffsetSeconds` | number | Offset from UTC in seconds. |
| `forecastDays` | number | Number of forecast days requested. |
| `pastDays` | number | Number of past days included. |
| `hourlyVariables` | string | Comma-separated hourly variables returned. |
| `dailyVariables` | string | Comma-separated daily variables returned. |
| `hours` | number | Count of hourly timesteps. |
| `days` | number | Count of daily timesteps. |
| `startTime` | string | First timestamp in the series. |
| `endTime` | string | Last timestamp in the series. |
| `hourlyUnits` | object | Unit for each hourly variable. |
| `hourly` | object | Hourly series: parallel arrays keyed by variable. |
| `dailyUnits` | object | Unit for each daily variable. |
| `daily` | object | Daily series: parallel arrays keyed by variable. |
| `scrapedAt` | string | ISO timestamp when the row was produced. |

### Related Actors

- [CoinGecko Scraper](https://apify.com/hipersoft/coingecko-scraper) — live cryptocurrency prices, market cap and volume.
- [Yahoo Finance Scraper](https://apify.com/hipersoft/yahoo-finance-scraper) — quotes and OHLCV history for stocks, ETFs and forex.
- [OpenStreetMap POI Scraper](https://apify.com/hipersoft/osm-poi-scraper) — points of interest by area and category.

### FAQ

**Can I look up many locations in one run?**
Yes. Add as many place names and coordinate objects as you like; each one becomes its own row in the dataset.

**Which weather variables can I request?**
Common hourly variables such as `temperature_2m`, `precipitation`, `windspeed_10m`, `relativehumidity_2m`, `cloudcover` and `weathercode`, plus daily aggregates like `temperature_2m_max`, `temperature_2m_min` and `precipitation_sum`.

**Can I get past weather too?**
Yes — set `pastDays` to include recent history before today alongside the forecast.

**Does it use local time?**
Set `timezone` to `auto` to return each location's local time, or pass an IANA name like `Asia/Singapore` or `UTC`.

**Can I connect this to n8n?**
Yes. Run the actor from n8n with the [Apify node](https://docs.n8n.io/integrations/builtin/app-nodes/n8n-nodes-base.apify/) (or an HTTP Request node against the Apify API), trigger it on a schedule, and pipe the structured weather rows straight into your workflow — Slack alerts, spreadsheets, databases and more.

**Can I connect this to my other tools?**
Yes. It works with almost any cloud service or web app through [integrations on the Apify platform](https://apify.com/integrations) — [Make](https://apify.com/integrations/make), [Zapier](https://apify.com/integrations/zapier), [Slack](https://docs.apify.com/platform/integrations/slack), [Google Drive](https://docs.apify.com/platform/integrations/drive) and [many more](https://apify.com/integrations), plus the [Apify API](https://docs.apify.com/api/v2), JavaScript/Python clients and MCP. Or use [webhooks](https://docs.apify.com/platform/integrations/webhooks) to trigger an action whenever a run finishes.

**What export formats are available?**
JSON, CSV, Excel and XML, plus programmatic access through the Apify API.

### Notes

Original clean-room implementation. Returns public weather data; you are responsible for compliant use. All trademarks belong to their respective owners.

# Actor input Schema

## `places` (type: `array`):

Place names to look up, one per line (e.g. "Singapore", "London", "New York"). Each name is resolved to coordinates automatically before its forecast is fetched. Use this OR the Locations field below (you can combine both).

## `locations` (type: `array`):

Exact coordinates as a list of objects: {"name": "HQ", "latitude": 1.29, "longitude": 103.85}. The optional name is used as a label; latitude and longitude are required. Use this when you already know the coordinates.

## `hourly` (type: `array`):

Hourly weather variables to include, one per line (e.g. temperature\_2m, precipitation, windspeed\_10m, relativehumidity\_2m, cloudcover, weathercode). Leave as-is for a sensible default set.

## `daily` (type: `array`):

Optional daily aggregate variables, one per line (e.g. temperature\_2m\_max, temperature\_2m\_min, precipitation\_sum, windspeed\_10m\_max, weathercode). Leave empty to skip daily data.

## `forecastDays` (type: `integer`):

How many days of forecast to fetch, from today forward (1–16).

## `timezone` (type: `string`):

Timezone for the returned timestamps. Use "auto" to match each location's local time, or an IANA name like "Asia/Singapore" or "UTC".

## `pastDays` (type: `integer`):

Also include this many days of recent past weather before today (0–92). Leave at 0 for forecast only.

## `proxyConfiguration` (type: `object`):

Optional proxy settings for the run. Not required — the weather data is fetched over plain HTTP.

## Actor input object example

```json
{
  "places": [
    "Singapore",
    "London"
  ],
  "locations": [],
  "hourly": [
    "temperature_2m",
    "precipitation",
    "windspeed_10m"
  ],
  "daily": [],
  "forecastDays": 7,
  "timezone": "auto",
  "pastDays": 0,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `results` (type: `string`):

The results as dataset items.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "places": [
        "Singapore",
        "London"
    ],
    "locations": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("hipersoft/open-meteo-weather-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "places": [
        "Singapore",
        "London",
    ],
    "locations": [],
}

# Run the Actor and wait for it to finish
run = client.actor("hipersoft/open-meteo-weather-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "places": [
    "Singapore",
    "London"
  ],
  "locations": []
}' |
apify call hipersoft/open-meteo-weather-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,hipersoft/open-meteo-weather-scraper"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/hVzIJ8sWOAjdHQH98/builds/NAPAriXmc5vpZFd4u/openapi.json