# Global Weather Scraper (`agentx/global-weather-scraper`) Actor

Get weather for any country, region, city, or town — fast and cheap, with upcoming forecasts or historical date ranges returned as a daily list.

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

## Pricing

from $10.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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

## Global Weather Scraper API — Structured Weather Extraction for Pipelines & Integrations

[![Developer Tools](https://img.shields.io/badge/Category-Developer%20Tools-ffd700?style=for-the-badge&color=ffd700)](https://apify.com/agentx/global-weather-scraper?fpr=aiagentapi) [![Automation](https://img.shields.io/badge/Category-Automation-ffd700?style=for-the-badge&color=ffd700)](https://apify.com/agentx/global-weather-scraper?fpr=aiagentapi) [![Global Coverage](https://img.shields.io/badge/Coverage-Global-ffd700?style=for-the-badge&color=ffd700)](https://apify.com/agentx/global-weather-scraper?fpr=aiagentapi) [![Reliability](https://img.shields.io/badge/Reliability-99.9%25-28a745?style=for-the-badge)](https://apify.com/agentx/global-weather-scraper?fpr=aiagentapi)

Extract structured daily weather datasets for any country, region, city, or town with 50+ fields per day item, covering forecast windows up to 16 days and historical date ranges up to one year. Each dataset item contains daily summaries, 24-hour hourly breakdowns, current conditions, and air quality signals — all serialized as enriched JSON for downstream pipelines, monitoring systems, and AI agent workflows.

---

### Why Choose This Weather Extraction API

#### Structured Output Designed for Integration Pipelines

**📡 Single-Location, Multi-Dimension Extraction**
One API call resolves a place name via geocoding and returns the full weather dataset: daily summaries, hourly rows per day, current conditions, and air quality — structured for direct ingestion into data pipelines, event-driven workflows, or AI agents without additional preprocessing.

**📊 50+ Fields Per Day Item**
Each day record exposes complete weather intelligence including temperature ranges (max/min/mean), apparent temperature, wind speed and gust vectors with compass labels, precipitation totals, UV index, sunrise/sunset with UTC offset, daylight hours, and current real-time readings for all variables.

**🌬️ Integrated Air Quality Signals**
Every result includes European AQI, US AQI, PM2.5, PM10, carbon monoxide, carbon dioxide, nitrogen dioxide, sulphur dioxide, ozone, ammonia, methane, dust, UV index, and five pollen types (alder, birch, grass, mugwort, ragweed). Historical runs return hourly air quality rows aligned to the requested date range.

**🗓️ Forecast & Historical Modes**
Target upcoming weather with the `days` parameter (1–16 day forecast window) or extract historical records using `start_date` / `end_date` with support for ranges up to 366 days. Both modes share the same output schema, enabling consistent downstream processing.

**🌍 Global Location Resolution**
Accepts any country, state, province, region, city, town, district, or village as a free-text string. Geocoding resolves casual inputs like `Munich`, `Ontario, Canada`, or `Chiang Mai, Thailand` into precise coordinates and returns enriched location metadata: resolved name, country, region, city, latitude, longitude, and timezone.

**🔗 Schema-Consistent Enriched Records**
Every dataset item carries processor metadata, ISO 8601 timestamps, mode indicator, and full location context fields — enabling deterministic joins with upstream datasets, audit trails, and multi-run deduplication in data warehouses.

---

### Quick Start Guide

#### Extract Weather Data in 3 Steps

##### Step 1: Configure Your Target Location

[Open Actor Input](https://console.apify.com/actors/Yn1ksjorQhCtBcLN6/input?fpr=aiagentapi)

Enter a location string in the **Location** field. For forecast mode, set **Days** (1–16). For historical mode, set both **Start Date** and **End Date**.

##### Step 2: Run the Extraction

Click **▷ Start**. The actor geocodes the input, retrieves weather and air quality data, and outputs one structured dataset item per calendar day.

##### Step 3: Access Structured Output

Export results as JSON or access programmatically via the Apify Dataset API. Each item contains the full day's weather schema including hourly and air quality arrays.

---

### Input Parameters

| Parameter    | Type    | Required | Description                                                                           | Example                      |
| ------------ | ------- | -------- | ------------------------------------------------------------------------------------- | ---------------------------- |
| `location`   | string  | ✅ Yes   | Target country, region, city, town, or district for extraction                        | `"Tokyo, Japan"`             |
| `start_date` | string  | ❌ No    | Historical start date — ISO date (`YYYY-MM-DD`) or relative period (`30 days`, `2 weeks`) | `"2025-04-01"`           |
| `end_date`   | string  | ❌ No    | Historical end date — ISO date or relative period (`1 day`, `1 week`)                 | `"2025-04-21"`               |
| `days`       | integer | ❌ No    | Forecast window in days (1–16) when `start_date`/`end_date` are not configured        | `3`                          |

#### Date Format Options

**Absolute dates** (`YYYY-MM-DD`):
- `"2025-04-01"` — Specific calendar date

**Relative periods** (resolved relative to extraction date):
- `"30 days"` — 30 calendar days back from today
- `"2 weeks"` — 14 days back
- `"1 month"` — 30 days back

> Historical date range must not exceed 366 days. Both `start_date` and `end_date` must be provided together.

#### Example Input — Forecast Mode

```json
{
  "location": "Tokyo, Japan",
  "days": 3
}
````

#### Example Input — Historical Mode

```json
{
  "location": "Tokyo, Japan",
  "start_date": "2025-04-01",
  "end_date": "2025-04-07"
}
```

***

### Output Data Schema

Each dataset item represents one calendar day. The schema is consistent across forecast and historical modes.

#### Core Fields

| Field                           | Type    | Description                                                                  |
| ------------------------------- | ------- | ---------------------------------------------------------------------------- |
| `processor`                     | string  | Apify actor URL that processed this record                                   |
| `processed_at`                  | string  | ISO 8601 UTC timestamp when this record was created                          |
| `status`                        | string  | Extraction status (`success`)                                                |
| `mode`                          | string  | `forecast` or `historical`                                                   |
| `start_date`                    | string  | Historical start date when date-range mode is active, otherwise `null`       |
| `end_date`                      | string  | Historical end date when date-range mode is active, otherwise `null`         |

#### Location Fields

| Field       | Type   | Description                                          |
| ----------- | ------ | ---------------------------------------------------- |
| `location`  | string | Resolved full place name                             |
| `country`   | string | Country name of the resolved location                |
| `region`    | string | Resolved state, province, or county                  |
| `city`      | string | Resolved city, town, or municipality                 |
| `latitude`  | number | Latitude coordinate (6 decimal places)               |
| `longitude` | number | Longitude coordinate (6 decimal places)              |
| `timezone`  | string | IANA timezone identifier (e.g. `Asia/Tokyo`)         |

#### Daily Summary Fields

| Field                           | Type    | Description                                                  |
| ------------------------------- | ------- | ------------------------------------------------------------ |
| `date`                          | string  | Calendar day (`YYYY-MM-DD`)                                  |
| `weather`                       | string  | Human-readable weather label (e.g. `Partly cloudy`)          |
| `temperature_max`               | number  | Maximum temperature (°C)                                     |
| `temperature_min`               | number  | Minimum temperature (°C)                                     |
| `temperature_mean`              | number  | Mean temperature (°C)                                        |
| `apparent_temperature_max`      | number  | Maximum feels-like temperature (°C)                          |
| `apparent_temperature_min`      | number  | Minimum feels-like temperature (°C)                          |
| `wind_speed_max`                | number  | Maximum wind speed (km/h)                                    |
| `wind_gusts_max`                | number  | Maximum wind gust speed (km/h)                               |
| `wind_direction_dominant`       | number  | Dominant wind direction in degrees                           |
| `wind_direction_label`          | string  | Compass label (`N`, `NE`, `S`, `SW`, etc.)                   |
| `precipitation_sum`             | number  | Total precipitation (mm)                                     |
| `precipitation_probability_max` | number  | Maximum precipitation probability (%)                        |
| `rain_sum`                      | number  | Total rain (mm)                                              |
| `snowfall_sum`                  | number  | Total snowfall (cm)                                          |
| `precipitation_hours`           | number  | Hours with precipitation                                     |
| `uv_index_max`                  | number  | Maximum UV index                                             |
| `sunrise`                       | string  | Sunrise time with UTC offset (e.g. `2026-04-22T04:59+09:00`) |
| `sunset`                        | string  | Sunset time with UTC offset                                  |
| `daylight_hours`                | number  | Total daylight hours                                         |
| `sunshine_hours`                | number  | Total sunshine hours                                         |

#### Current Conditions Fields (forecast mode only)

| Field                          | Type    | Description                                       |
| ------------------------------ | ------- | ------------------------------------------------- |
| `current_temperature`          | number  | Current air temperature (°C)                      |
| `current_apparent_temperature` | number  | Current feels-like temperature (°C)               |
| `current_humidity`             | number  | Current relative humidity (%)                     |
| `current_weather`              | string  | Current weather label                             |
| `current_cloud_cover`          | number  | Current cloud cover (%)                           |
| `current_pressure`             | number  | Current atmospheric pressure (hPa)                |
| `current_visibility_km`        | number  | Current visibility (km)                           |
| `current_uv_index`             | number  | Current UV index                                  |
| `current_wind_speed`           | number  | Current wind speed (km/h)                         |
| `current_wind_direction`       | number  | Current wind direction (degrees)                  |
| `current_wind_direction_label` | string  | Compass label for current wind direction          |
| `current_wind_gusts`           | number  | Current wind gust speed (km/h)                    |
| `current_is_day`               | boolean | Whether the observation is daytime                |
| `current_precipitation`        | number  | Current precipitation amount (mm)                 |
| `current_rain`                 | number  | Current rain amount (mm)                          |
| `current_showers`              | number  | Current shower amount (mm)                        |
| `current_snowfall`             | number  | Current snowfall (cm)                             |

#### Air Quality & Array Fields

| Field                 | Type   | Description                                                                        |
| --------------------- | ------ | ---------------------------------------------------------------------------------- |
| `air_quality_status`  | string | `forecast`, `historical`, or `unavailable`                                         |
| `air_quality_note`    | string | Plain-language note about air quality data availability                            |
| `hourly_forecast`     | array  | 24 hourly weather rows for this day (time, temperature, wind, precipitation, etc.) |
| `air_quality_current` | object | Current AQI, pollutant concentrations, pollen, and UV values                       |
| `air_quality_hourly`  | array  | Hourly air quality rows for this day                                               |

#### Example Output

```json
[
  {
    "processor": "https://apify.com/agentx/global-weather-scraper?fpr=aiagentapi",
    "processed_at": "2026-04-22T04:08:06+00:00",
    "status": "success",
    "mode": "forecast",
    "start_date": null,
    "end_date": null,
    "location": "Tokyo, Japan",
    "country": "Japan",
    "region": "Tokyo",
    "city": null,
    "latitude": 35.67686,
    "longitude": 139.763895,
    "timezone": "Asia/Tokyo",
    "temperature_unit": "celsius",
    "wind_speed_unit": "kmh",
    "date": "2026-04-22",
    "weather": "Partly cloudy",
    "temperature_max": 21.5,
    "temperature_min": 8.2,
    "temperature_mean": 15.5,
    "apparent_temperature_max": 21.9,
    "apparent_temperature_min": 5.7,
    "wind_speed_max": 12.2,
    "wind_gusts_max": 52.2,
    "wind_direction_dominant": 200,
    "wind_direction_label": "S",
    "precipitation_sum": 0.0,
    "precipitation_probability_max": 3,
    "rain_sum": 0.0,
    "snowfall_sum": 0.0,
    "precipitation_hours": 0.0,
    "uv_index_max": 7.5,
    "sunrise": "2026-04-22T04:59+09:00",
    "sunset": "2026-04-22T18:19+09:00",
    "daylight_hours": 13.3,
    "sunshine_hours": 10.0,
    "current_temperature": 20.9,
    "current_apparent_temperature": 20.2,
    "current_humidity": 54,
    "current_weather": "Mainly clear",
    "current_cloud_cover": 45,
    "current_pressure": 1011.0,
    "current_visibility_km": 24.1,
    "current_uv_index": 6.5,
    "current_wind_speed": 11.5,
    "current_wind_direction": 178,
    "current_wind_direction_label": "S",
    "current_wind_gusts": 51.8,
    "current_is_day": true,
    "current_precipitation": 0.0,
    "current_rain": 0.0,
    "current_showers": 0.0,
    "current_snowfall": 0.0,
    "air_quality_status": "forecast",
    "air_quality_note": null,
    "hourly_forecast": [
      {
        "time": "2026-04-22T00:00+09:00",
        "weather": "Clear sky",
        "temperature": 11.9,
        "apparent_temperature": 9.1,
        "humidity": 44,
        "wind_speed": 4.4,
        "wind_gusts": 6.1,
        "wind_direction": 325,
        "wind_direction_label": "NW",
        "cloud_cover": 2,
        "precipitation": 0.0,
        "rain": 0.0,
        "pressure": 1016.7,
        "uv_index": 0.0,
        "is_day": false
      }
    ],
    "air_quality_current": {
      "time": "2026-04-22T13:00+09:00",
      "european_aqi": 60,
      "us_aqi": 69,
      "pm2_5": 12.8,
      "pm10": 17.7,
      "carbon_monoxide": 173.0,
      "carbon_dioxide": 454,
      "nitrogen_dioxide": 6.6,
      "sulphur_dioxide": 6.6,
      "ozone": 131.0,
      "uv_index": 4.2
    },
    "air_quality_hourly": [
      {
        "time": "2026-04-22T13:00+09:00",
        "european_aqi": 60,
        "us_aqi": 69,
        "pm2_5": 12.8,
        "pm10": 17.7
      }
    ]
  }
]
```

***

### Integration Examples

#### Actor ID

```
Yn1ksjorQhCtBcLN6
```

#### 🐍 Python Integration

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_API_TOKEN")

run_input = {
    "location": "Tokyo, Japan",
    "days": 3,
}

run = client.actor("Yn1ksjorQhCtBcLN6").call(run_input=run_input)

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["date"], item["weather"], item["temperature_max"])
```

#### 🟨 JavaScript Integration

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });

const run = await client.actor("Yn1ksjorQhCtBcLN6").call({
  location: "Tokyo, Japan",
  days: 3,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach(item => console.log(item.date, item.weather, item.temperature_max));
```

#### Ⓜ️ Make.com Integration

1. Login to **[Make.com](https://www.make.com/en/register?pc=marketingme)**
2. Add module **"Run an Actor"**
3. Enable **Map** toggle → paste Actor ID `Yn1ksjorQhCtBcLN6`
4. Click **⟳ Refresh** to load the input schema
5. Configure `location`, `days` (or `start_date` / `end_date`)
6. Set **"Run synchronously"** to **YES**
7. Add module **"Get Dataset Items"** → select `defaultDatasetId`

#### 🎱 N8N Integration

1. Add **Apify → Run Actor and get dataset** node
2. Actor → By ID → paste `Yn1ksjorQhCtBcLN6`
3. Configure input JSON with `location` and `days` parameters
4. Route dataset items to downstream nodes (Google Sheets, webhooks, AI agents)

#### 🧾 JSON-LD Metadata

```json
{
  "@context": "https://schema.org",
  "@type": "SoftwareApplication",
  "name": "Global Weather Scraper",
  "applicationCategory": "DeveloperApplication",
  "operatingSystem": "Web",
  "description": "Extracts structured daily weather datasets for any country, region, city, or town — forecast and historical date ranges with hourly breakdowns, air quality signals, and enriched location metadata.",
  "url": "https://apify.com/agentx/global-weather-scraper?fpr=aiagentapi",
  "dateModified": "2026-04-22"
}
```

***

### Pricing & Cost Calculator

| Event           | Price   | Description                                                                              |
| --------------- | ------- | ---------------------------------------------------------------------------------------- |
| **Actor Start** | $0.02   | Charged when the Actor starts. Billed per GB of memory allocated (minimum 1 event).     |
| **Result**      | $0.01   | Charged per completed location weather extraction (one event per run).                  |

#### Example Cost Calculation

| Scenario                               | Result Items | Estimated Cost |
| -------------------------------------- | ------------ | -------------- |
| Single location, 3-day forecast        | 3 day items  | ~$0.03         |
| Single location, 7-day historical      | 7 day items  | ~$0.03         |
| Single location, 30-day historical     | 30 day items | ~$0.03         |

> Pricing is per completed location lookup, not per day item. All day items for a single run count as one charged Weather Result event. The Actor Start event is billed once per run based on memory allocation.

***

### Use Cases & Applications

#### Geospatial Intelligence & Location Enrichment

Enrich address or property datasets with weather baseline signals — precipitation seasonality, temperature ranges, UV exposure, and air quality scores — for real estate valuation models, insurance underwriting, or site suitability analysis.

#### Climate Monitoring & Event Detection

Integrate the weather extraction API into scheduled pipelines to monitor climate conditions for specific regions over time. Correlate weather signals with supply chain events, agricultural yield data, or demand forecasting models.

#### AI Agent & LLM Workflows

Provide structured weather context to AI agents processing location-based queries, travel planning prompts, or environmental risk assessments. The consistent JSON schema integrates directly with LangChain tools, function-calling APIs, and MCP server pipelines.

#### Logistics & Operations Intelligence

Extract weather conditions for origin and destination nodes in routing systems. Integrate into SLA monitoring pipelines to flag weather risk flags — high wind, precipitation, visibility — aligned to specific operational dates.

#### Research & Academic Data Collection

Bulk-extract historical weather records for climate research, economic correlation studies, or social science datasets requiring localized weather variables at daily or hourly resolution.

#### Market Research & Competitive Intelligence

Correlate weather conditions with retail performance, foot traffic, and consumer behaviour signals. Extract seasonal weather baselines for geographic market segmentation and demand forecasting.

***

### FAQ

#### How do I extract weather for a small town not on major maps?

Enter the town name and country as a free-text string (e.g. `Hakuba, Japan`). The geocoder resolves the location from the full address hierarchy — if the place exists in OSM, it will return coordinates.

#### What is the output schema for historical vs. forecast mode?

Both modes return the same top-level daily schema. Forecast mode additionally populates all `current_*` fields. Historical mode omits `current_*` fields and returns hourly air quality rows in `air_quality_hourly` rather than a `air_quality_current` object.

#### Can I extract weather for entire regions or countries?

Yes. You can specify `Bavaria, Germany` or `Ontario, Canada` as the target location. The geocoder resolves to the centroid coordinate of the region, returning representative weather for that area.

#### How do I integrate this API into a scheduled monitoring pipeline?

Use the Apify API or SDK to trigger runs on a schedule with a fixed `location` and `days: 1` for daily monitoring. Each run outputs a single day item containing all current-day weather and air quality signals.

#### What air quality variables are included in the output?

Each `air_quality_current` object contains: `european_aqi`, `us_aqi`, `pm2_5`, `pm10`, `carbon_monoxide`, `carbon_dioxide`, `nitrogen_dioxide`, `sulphur_dioxide`, `ozone`, `ammonia`, `methane`, `dust`, `uv_index`, `alder_pollen`, `birch_pollen`, `grass_pollen`, `mugwort_pollen`, `ragweed_pollen`.

#### What is the maximum historical date range per extraction?

Up to 366 days per run. For longer ranges, split into multiple runs with adjacent date windows.

#### How does this compare to commercial weather APIs like Bright Data or Meteomatics?

This actor delivers structured, per-day enriched records via Apify's dataset API with zero authentication setup, direct JSON output, and a consistent schema across both forecast and historical modes. No API key management or rate limit negotiation is required.

***

### SEO Keywords & Search Terms

#### Primary Keywords

- global weather scraper API
- weather extraction pipeline
- structured weather dataset API
- weather data extraction JSON

#### Long-Tail Keywords

- extract daily weather data by city name API
- historical weather dataset by location API
- weather forecast API integration pipeline
- structured weather signals for AI agents

#### Technical Keywords

- weather API Apify actor
- daily weather JSON extraction
- open-meteo structured dataset
- weather data enrichment pipeline
- air quality signals extraction API

#### Industry Keywords

- weather data for logistics routing
- climate signals real estate enrichment
- weather API for AI agent workflows
- location weather extraction developer tool

***

### Trust & Certifications

[![Apify](https://img.shields.io/badge/Verified-Apify%20Platform-0f9d58?style=flat-square)](https://apify.com/agentx/global-weather-scraper?fpr=aiagentapi) [![Uptime](https://img.shields.io/badge/Uptime-99.9%25-28a745?style=flat-square)](https://apify.com/agentx/global-weather-scraper?fpr=aiagentapi)

- **Data Source**: Open-Meteo — open-source weather API with 99.9% uptime SLA and global coverage
- **Geocoding**: Nominatim / OpenStreetMap — authoritative open geodata with global address resolution
- **Output Format**: Validated structured JSON schema with consistent field types across all extraction modes
- **Infrastructure**: Runs on Apify's managed cloud platform with automatic scaling and monitoring

***

### Legal & Compliance

**Data Rights**: This actor extracts publicly available weather and air quality data from open APIs. The extracted data represents environmental observations and is not subject to copyright restrictions.

**Privacy Compliance (GDPR/CCPA)**: No personal data is collected or processed. Location inputs are geocoded to geographic coordinates only. No user identification or tracking is performed.

**Platform Terms of Service**: Data is sourced from Open-Meteo (CC BY 4.0 license) and Nominatim/OpenStreetMap (ODbL license). Commercial use is permitted under these licenses. Always verify compliance with the terms of your downstream use case.

**Accuracy Disclaimer**: Weather forecast data is provided for informational and integration purposes. Do not use extracted data as the sole input for safety-critical, aviation, medical, or emergency decisions. Verify conditions locally for high-stakes operations.

**Enterprise Support**: Contact [t.me/AiAgentApi](https://t.me/AiAgentApi) for enterprise SLA, custom extraction configurations, or bulk data delivery arrangements.

***

### Related Tools

#### Jobs

- [All Jobs Scraper](https://apify.com/agentx/all-jobs-scraper?fpr=aiagentapi)
- [Glassdoor Hiring Scraper](https://apify.com/agentx/glassdoor-hiring-scraper?fpr=aiagentapi)
- [Indeed Hiring Scraper](https://apify.com/agentx/indeed-hiring-scraper?fpr=aiagentapi)
- [LinkedIn Hiring Scraper](https://apify.com/agentx/linkedin-hiring-scraper?fpr=aiagentapi)

#### Social Media

- [Instagram Creator Scraper](https://apify.com/agentx/instagram-creator-scraper?fpr=aiagentapi)
- [Instagram Post Reel Scraper](https://apify.com/agentx/instagram-post-reel-scraper?fpr=aiagentapi)
- [Instagram Trending Scraper](https://apify.com/agentx/instagram-trending-scraper?fpr=aiagentapi)
- [LinkedIn Company Scraper](https://apify.com/agentx/linkedin-company-scraper?fpr=aiagentapi)
- [LinkedIn Profile Scraper](https://apify.com/agentx/linkedin-profile-scraper?fpr=aiagentapi)
- [Reddit Author Scraper](https://apify.com/agentx/reddit-author-scraper?fpr=aiagentapi)
- [Reddit Viral Scraper](https://apify.com/agentx/reddit-viral-scraper?fpr=aiagentapi)
- [SubReddit Info Scraper](https://apify.com/agentx/subreddit-info-scraper?fpr=aiagentapi)
- [SubReddit Post Scraper](https://apify.com/agentx/subreddit-post-scraper?fpr=aiagentapi)
- [Subreddit Member Scraper](https://apify.com/agentx/subreddit-member-scraper?fpr=aiagentapi)
- [Telegram Chat Scraper](https://apify.com/agentx/telegram-chat-scraper?fpr=aiagentapi)
- [Telegram Group Inviter](https://apify.com/agentx/telegram-group-inviter?fpr=aiagentapi)
- [Telegram Info Scraper](https://apify.com/agentx/telegram-info-scraper?fpr=aiagentapi)
- [Telegram Member Scraper](https://apify.com/agentx/telegram-member-scraper?fpr=aiagentapi)
- [Telegram Private Group Scraper](https://apify.com/agentx/telegram-private-group-scraper?fpr=aiagentapi)
- [TikTok Creator Scraper](https://apify.com/agentx/tiktok-creator-scraper?fpr=aiagentapi)
- [Twitter Community Scraper](https://apify.com/agentx/twitter-community-scraper?fpr=aiagentapi)
- [Twitter Info Scraper](https://apify.com/agentx/twitter-info-scraper?fpr=aiagentapi)

#### Video

- [All Video Scraper](https://apify.com/agentx/all-video-scraper?fpr=aiagentapi)
- [Live Stream Transcript](https://apify.com/agentx/live-stream-transcript?fpr=aiagentapi)
- [TikTok Live Downloader](https://apify.com/agentx/tiktok-live-downloader?fpr=aiagentapi)
- [TikTok Transcript](https://apify.com/agentx/tiktok-transcript?fpr=aiagentapi)
- [Video Caption Scraper](https://apify.com/agentx/video-caption-scraper?fpr=aiagentapi)
- [Video Transcript](https://apify.com/agentx/video-transcript?fpr=aiagentapi)
- [Video to Social Post](https://apify.com/agentx/video-to-social-post?fpr=aiagentapi)
- [YouTube Market Intelligence](https://apify.com/agentx/youtube-market-intelligence?fpr=aiagentapi)
- [YouTube Transcript](https://apify.com/agentx/youtube-transcript?fpr=aiagentapi)

#### Real Estate

- [Realtor Property Scraper](https://apify.com/agentx/realtor-property-scraper?fpr=aiagentapi)
- [Zillow For Sale Scraper](https://apify.com/agentx/zillow-for-sale-scraper?fpr=aiagentapi)

#### Maps & Local

- [Google Maps Store Scraper](https://apify.com/agentx/google-maps-store-scraper?fpr=aiagentapi)

***

### Support & Community

- 💬 **Actor Support**: [t.me/AiAgentApi](https://t.me/AiAgentApi)
- 👥 **Join Group**: [t.me/Apify\_Actor](https://t.me/Apify_Actor)
- 🔌 **All AgentX APIs**: [apify.com/agentx](https://apify.com/agentx?fpr=aiagentapi)
- 📖 **Actor Page**: [apify.com/agentx/global-weather-scraper](https://apify.com/agentx/global-weather-scraper?fpr=aiagentapi)

***

**Last Updated:** April 22, 2026

# Actor input Schema

## `location` (type: `string`):

Any country, region, city, town, or district to extract weather for. Examples: "Tokyo, Japan", "Ontario, Canada", "Munich"

## `days` (type: `integer`):

Number of forecast days to extract from today when start\_date and end\_date are not configured

## `start_date` (type: `string`):

Optional historical start date for date-range extraction. Accepts ISO date (YYYY-MM-DD) or relative period like '30 days' or '2 weeks'.

## `end_date` (type: `string`):

Optional historical end date to close the date-range extraction window. Accepts ISO date (YYYY-MM-DD) or relative period like '1 day' or '1 week'.

## Actor input object example

```json
{
  "location": "Tokyo, Japan",
  "days": 3,
  "start_date": "2025-04-01",
  "end_date": "2025-04-21"
}
```

# Actor output Schema

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

List of daily weather items for the requested location

# 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 = {
    "location": "Tokyo, Japan",
    "days": 3,
    "start_date": "",
    "end_date": ""
};

// Run the Actor and wait for it to finish
const run = await client.actor("agentx/global-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 = {
    "location": "Tokyo, Japan",
    "days": 3,
    "start_date": "",
    "end_date": "",
}

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

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

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

```

## CLI example

```bash
echo '{
  "location": "Tokyo, Japan",
  "days": 3,
  "start_date": "",
  "end_date": ""
}' |
apify call agentx/global-weather-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=agentx/global-weather-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Global Weather Scraper",
        "description": "Get weather for any country, region, city, or town — fast and cheap, with upcoming forecasts or historical date ranges returned as a daily list.",
        "version": "0.0",
        "x-build-id": "DFRZg6fNZafLajnAI"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/agentx~global-weather-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-agentx-global-weather-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/agentx~global-weather-scraper/runs": {
            "post": {
                "operationId": "runs-sync-agentx-global-weather-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/agentx~global-weather-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-agentx-global-weather-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "location"
                ],
                "properties": {
                    "location": {
                        "title": "🌍 Location",
                        "type": "string",
                        "description": "Any country, region, city, town, or district to extract weather for. Examples: \"Tokyo, Japan\", \"Ontario, Canada\", \"Munich\""
                    },
                    "days": {
                        "title": "📊 Days",
                        "minimum": 1,
                        "maximum": 16,
                        "type": "integer",
                        "description": "Number of forecast days to extract from today when start_date and end_date are not configured"
                    },
                    "start_date": {
                        "title": "📅 Start Date",
                        "type": "string",
                        "description": "Optional historical start date for date-range extraction. Accepts ISO date (YYYY-MM-DD) or relative period like '30 days' or '2 weeks'."
                    },
                    "end_date": {
                        "title": "📅 End Date",
                        "type": "string",
                        "description": "Optional historical end date to close the date-range extraction window. Accepts ISO date (YYYY-MM-DD) or relative period like '1 day' or '1 week'."
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
