8 Best Free Weather APIs for Linux: Forecasts, Limits & Pricing Compared

Weather data shows up in more places than a forecast widget. Linux users and developers often use it in shell scripts, monitoring dashboards, automation tools, travel apps, IoT projects, reports, and location-based services.

A simple command-line weather lookup is fine for quick checks, but real projects usually need structured data, reliable endpoints, clear documentation, and output formats that work smoothly with scripts.

That is where weather APIs help. Strong options provide forecast data, historical records, location search, JSON or CSV responses, and practical free plans for testing. Some are simple enough for hobby projects, while others are built for analytics, business applications, or larger data workflows.

This list focuses on weather APIs suitable for Linux scripts and developer projects, with attention to practical use cases, data access, documentation, and ease of integration into everyday development work.

What Makes a Weather API Useful for Linux Scripts?

Linux scripts work best with predictable data. A weather API should return clean responses, support common formats such as JSON and CSV, and make it easy to request data for a specific location, date, or time range. That matters when a script runs from cron, feeds a dashboard, triggers an alert, or saves results for later analysis.

For Linux users, output format is often as important as the data itself. API responses that can be saved, filtered, sorted, or converted are easier to reuse in shell scripts and reporting workflows, especially when developers need to view CSV files in the Linux terminal before passing the data into another tool.

Good documentation matters as well. Developers should be able to test an endpoint with curl, parse the response with jq, store the results in a file, and handle errors without having to guess how the API behaves. Rate limits, authentication, uptime, and access to historical data become more important once a project moves beyond basic testing.

Top Weather APIs for Linux Scripts and Developer Projects

1. Visual Crossing

Best for: Historical weather data in scripts

Visual Crossing Weather API focuses heavily on historical weather records, which makes it useful for scripts that compare past conditions, generate reports, or feed data into analytics tools. It returns both JSON and CSV, so you can pipe CSV output directly into standard shell tools or a local database without writing a custom parser.

For a typical Linux workflow, you request a date range for a specific location, save the response as CSV, and process it with standard tools. This works well for scheduled reports or dashboards that need to answer questions like "how much rain fell in this city last quarter?" or "what was the temperature trend over the past year?"

Usage

Shell:

curl -s "https://weather.visualcrossing.com/VisualCrossingWebServices/rest/services/timeline/London?key=YOUR_API_KEY&unitGroup=metric" | python3 -m json.tool

Python:

import requests

url = "https://weather.visualcrossing.com/VisualCrossingWebServices/rest/services/timeline/London"
params = {
    "key": "YOUR_API_KEY",
    "unitGroup": "metric"
}
response = requests.get(url, params=params, timeout=30)
response.raise_for_status()
data = response.json()
print(f"Current temp: {data['currentConditions']['temp']}")

What to check before you commit

• Historical depth: The Visualcrossing service provides access to 50+ years of history. Please note that NOT every location or weather element has complete coverage across the entire archive. Test your specific locations and date ranges.
• Rate limits: The free plan allows 1,000 weather records per day and only one concurrent request. If you run batch jobs that request large date ranges for many locations, you will need a paid tier.
• Location accuracy: Test a few locations against known conditions. Historical data quality can vary by region because the API blends station observations, radar, and satellite sources.
• Cost: Bulk historical queries add up. A single year of daily data for one location consumes roughly 365 records, so large batch jobs will quickly outgrow the free allowance.

Verdict

A solid choice when your script needs historical weather in a format that standard Linux tools can process. It handles forecasts and current conditions too, but its real strength is the unified timeline that lets you query past, present, and future through the same endpoint.

2. Open-Meteo

Best for: Free, open-source projects and quick prototypes

Open-Meteo is genuinely free for non-commercial use and requires no API key. You can test it immediately with curl, which makes it ideal for hobby scripts, prototypes, and anything you want to run without managing credentials.

The API returns clean JSON and supports forecasts up to 16 days, plus historical data back to 1940 through reanalysis models.

It also offers a wide range of variables:

• Temperature,
• Precipitation,
• Wind at multiple heights,
• Solar radiation,
• Soil moisture, and more.

That depth is unusual for a free service.

The weather APIs use latitude and longitude, but Open-Meteo also provides a separate Geocoding API that can convert city names or postal codes into coordinates. For arbitrary street addresses, you may still need a separate geocoding service.

Also, the free tier is strictly for non-commercial use. If your project generates revenue, you need a commercial license. The public service carries no uptime guarantee, and while rate limits are reasonable, heavy traffic from a single IP can get throttled.

Usage

Shell:

curl -s "https://api.open-meteo.com/v1/forecast?latitude=52.52&longitude=13.41&current=temperature_2m&daily=temperature_2m_max,temperature_2m_min&timezone=auto" | python3 -m json.tool

Python:

import requests

url = "https://api.open-meteo.com/v1/forecast"
params = {
    "latitude": 52.52,
    "longitude": 13.41,
    "current": "temperature_2m",
    "daily": ["temperature_2m_max", "temperature_2m_min"],
    "timezone": "auto"
}
response = requests.get(url, params=params, timeout=30)
response.raise_for_status()
data = response.json()
print(f"Current temp: {data['current']['temperature_2m']}")

What to check before you commit

• Location handling: Confirm you can supply coordinates or have a reliable way to convert addresses before calling the API.
• Commercial status: If your project is commercial, budget for a paid license. The free endpoint is not licensed for business use.
• Data source awareness: Current conditions come from model output, not live weather stations. For some use cases this is fine; for others it may feel slightly delayed compared to station observations.
• Geographic coverage of high-resolution data: 15-minute resolution is only available in Central Europe and North America. Other regions fall back to hourly data.

Verdict

An excellent starting point for personal scripts, education, and non-commercial tools. The lack of authentication removes a lot of friction. Just remember to handle geocoding yourself, and do not build a commercial product on the free endpoint.

3. OpenWeather

Best for: General-purpose weather data when you need broad coverage

OpenWeather is one of the most widely known weather APIs. It offers current conditions, forecasts, air quality, geocoding, and weather maps. The free tier is generous in volume (60 calls per minute, up to 1 million calls per month), which makes it attractive for scripts that poll frequently.

The free tier covers current weather, a 5-day forecast in 3-hour steps, air pollution data, geocoding, and basic weather maps. However, the more useful unified endpoint, One Call API 3.0/4.0, sits behind a paid subscription. That endpoint bundles current conditions, minute-by-minute forecasts, hourly forecasts, daily forecasts, government alerts, and historical data in a single response. On the free tier, you must call separate endpoints for basic current and forecast data.

Historical weather data goes back 47+ years, but you cannot access it on the free plan. You need at least the One Call API 3.0 subscription or a higher tier.

The free tier also carries a 95% availability target, which is lower than most paid weather services. For a production cron job, that gap matters.

Usage

Shell:

curl -s "https://api.openweathermap.org/data/2.5/weather?lat=51.5074&lon=-0.1278&appid=YOUR_API_KEY&units=metric" | python3 -m json.tool

Python:

import requests

url = "https://api.openweathermap.org/data/2.5/weather"
params = {
    "lat": 51.5074,
    "lon": -0.1278,
    "appid": "YOUR_API_KEY",
    "units": "metric"
}
response = requests.get(url, params=params, timeout=30)
response.raise_for_status()
data = response.json()
print(f"Current temp: {data['main']['temp']}")

What to check before you commit

• Free tier limits: 60 calls per minute and 1 million calls per month sounds like a lot, but the free data is less granular. You get 3-hour forecast steps, not hourly or minute-by-minute.
• Historical data access: If your script needs past weather, budget for a paid plan. The free tier does not include historical endpoints.
• Geocoding: The built-in city name lookup in the old weather endpoints is deprecated. OpenWeather now expects you to use their separate Geocoding API to convert addresses to coordinates.
• Uptime: The free tier promises 95% availability. Paid tiers target 99.5% or higher. If your script runs unattended, decide whether that risk is acceptable.
• Attribution: all plans require visible credit to OpenWeather in your application or output.

Verdict

A safe default for current conditions and basic forecasts, especially if you need high call volume without immediate cost. Just know that the free tier is more limited than it first appears. For unified forecasts, alerts, or historical data, you will need to pay.

4. WeatherAPI

Best for: Flexible location queries and a broad feature set without spending money

WeatherAPI.com stands out because it accepts almost any location format you can think of. Pass a city name, latitude and longitude, US zip code, UK postcode, Canadian postal code, METAR code, IATA airport code, or even an IP address. This saves you from running a separate geocoding step in your script.

The free tier gives you 100,000 calls per month, which is plenty for most personal or small-scale projects. You get current conditions, a 3-day forecast, and 1 day of historical data.

The API also offers astronomy data, time zone lookups, IP geolocation, and sports weather, though sports data is limited on the free tier. That is still a lot of functionality in one endpoint.

Please note that the free tier has clear boundaries. Historical data goes back only one day, and forecasts reach only three days ahead. If you need deeper history or longer forecasts, you will need a paid plan. Also, uptime is rated at 95.5%, which is lower than most paid alternatives, so occasional outages are expected.

One important detail about the historical data: WeatherAPI.com archives its own forecast output at the end of each day. It is not built from actual station observations. For casual comparisons or trend spotting, this is usually fine. For rigorous research or legal compliance, you may want a service that uses verified observational records instead.

Real-time data updates every 10 to 15 minutes, and forecast data refreshes every 4 to 6 hours. The API returns JSON or XML. You can also filter the response fields so you only get the variables you need, which keeps response sizes small.

Usage

Shell:

curl -s "https://api.weatherapi.com/v1/current.json?key=YOUR_API_KEY&q=London" | python3 -m json.tool

Python:

import requests

url = "https://api.weatherapi.com/v1/current.json"
params = {
    "key": "YOUR_API_KEY",
    "q": "London"
}
response = requests.get(url, params=params, timeout=30)
response.raise_for_status()
data = response.json()
print(f"Current temp: {data['current']['temp_c']}")

What to check before you commit

• Free tier limits: 100k calls per month sounds generous, but you only get 3 days of forecast and 1 day of history. If you need more, budget for at least the Starter tier.
• Historical data source: remember that historical records are archived forecasts, not ground-truth observations.
• Commercial use: unlike many free weather APIs, WeatherAPI.com explicitly allows commercial use on the free tier.
• Uptime: 95.5% on the free tier means occasional outages are expected. For a production cron job, consider a paid tier with 99% or higher uptime.
• Location flexibility: city names, zip codes, and airport codes work directly in the query parameter, so you may not need a separate geocoding API at all.

Verdict

A strong choice if you want one API that handles current weather, basic forecasts, astronomy, time zones, and IP lookup without extra setup. Just respect the free tier limits, and do not treat the historical archive as verified observational data.

5. National Weather Service API

Best for: Free US weather data without API keys or usage fees

The National Weather Service API is a public service funded by US taxpayers, so the data is completely free for any purpose. You do not need an API key. You only need to send a User-Agent header that identifies your application.

This API is ideal if your project focuses on the United States. It delivers forecasts, weather alerts, and station observations. The alert system is especially strong, since it pulls directly from the official government warning pipeline. If you are building a severe weather monitor, an emergency dashboard, or a civic tool for a US community, this is often the most authoritative source you can get.

The API uses a grid-based forecast system. Each location maps to a specific Weather Forecast Office and a grid coordinate. To get the forecast, you first call the /points/{latitude},{longitude} endpoint. That returns a link to the correct grid forecast URL for your location. Then you call that grid URL to fetch the actual forecast data. The grid resolution is roughly 2.5 km by 2.5 km, which is fine for most regional and local use cases.

You can retrieve 12-hour forecast periods for the next 7 days, hourly forecasts for the next 7 days, active alerts by state or zone, and recent observations from local weather stations. The API supports GeoJSON, JSON-LD, DWML, and CAP formats, so you can pick the one that fits your parser.

There are some practical limits to keep in mind. The API covers only the United States, so it is useless for global projects. Rate limits exist but are not published publicly. The documentation describes them as generous for typical use, and if you hit the limit you can usually retry after a few seconds. Still, if you run a high-traffic production service, you should cache responses and respect the retry behavior. Also, station observations may lag by up to 20 minutes because of upstream quality control processing.

Usage

Shell:

curl -s -A "MyWeatherApp (contact@example.com)" "https://api.weather.gov/points/39.7456,-97.0892" | python3 -m json.tool

Python:

import requests

url = "https://api.weather.gov/points/39.7456,-97.0892"
headers = {"User-Agent": "MyWeatherApp (contact@example.com)"}
response = requests.get(url, headers=headers, timeout=30)
response.raise_for_status()
data = response.json()
forecast_url = data["properties"]["forecast"]
print(f"Forecast URL: {forecast_url}")

What to check before you commit

• Geographic scope: this API serves US locations only. If you need global coverage, look elsewhere.
• Two-step lookup: you must resolve lat/lon to a grid endpoint before fetching forecasts. Cache the grid URL to reduce latency, but refresh it periodically because grid mappings can change.
• User-Agent header: the API requires this and may block requests that lack it.
• Data delays: observations can be delayed by up to 20 minutes, so do not treat this as a real-time stream for safety-critical decisions.
• Rate limits: they exist but are not documented with specific numbers. Build caching and retry logic into your script.

Verdict

The best zero-cost option for US-focused weather tools. It is authoritative, completely free, and requires no API key. Just remember it is US-only, and you will need to handle the grid-based lookup flow in your code.

6. Weatherbit

Best for: Current conditions and short daily forecasts in a single global API

Weatherbit is a commercial weather API with a limited free tier. The free plan gives you current weather data and 7-day daily forecasts. It does not include severe weather alerts, air quality, hourly forecasts, historical data, or maps. If you need any of those, you will have to upgrade to a paid tier.

The free tier allows 50 requests per day at 1 request per second, and you may use it only for non-commercial projects. That is enough for a small personal script or a hobby dashboard, but it will not support a busy application or any commercial use. Uptime on the free tier is 95%, which is lower than most paid competitors.

Weatherbit covers global locations. You can query by latitude and longitude, city name, postal code with country, or station ID. The docs recommend lat/lon for the most accurate results. Forecasts update about once per hour.

If you pay for a higher tier, Weatherbit expands into a broader environmental data platform. The Standard tier adds 16-day forecasts, hourly and minutely forecasts, lightning data, and severe weather alerts.

The Business tier adds historical weather, climate normals, air quality, agricultural weather, and energy-focused datasets. But on the free tier, you are limited to current conditions and 7-day daily forecasts.

Usage

Shell:

curl -s "https://api.weatherbit.io/v2.0/current?lat=35.7721&lon=-78.63861&key=YOUR_API_KEY&units=M" | python3 -m json.tool

Python:

import requests

url = "https://api.weatherbit.io/v2.0/current"
params = {
    "lat": 35.7721,
    "lon": -78.63861,
    "key": "YOUR_API_KEY",
    "units": "M"  # M = Metric, I = Imperial, S = Scientific
}
response = requests.get(url, params=params, timeout=30)
response.raise_for_status()
data = response.json()
print(f"Current temp: {data['data'][0]['temp']}")

What to check before you commit

• The free tier is strictly non-commercial. Do not use it for business projects.
• You get only 50 requests per day. If you poll more than twice per hour, you will hit the limit.
• Alerts and air quality are not free. If those matter to you, pick a different free API or pay for a Weatherbit upgrade.
• Uptime is 95% on the free tier. That is acceptable for hobby use but risky for anything important.
• Location lookup by city name or postal code can be ambiguous. Use lat/lon when possible.

Verdict

A decent free option if you only need current weather and a 7-day daily forecast for a non-commercial project. If you want alerts, air quality, or historical data, look elsewhere unless you are willing to pay.

7. Tomorrow.io

Best for: Core weather data with a generous free request quota for non-commercial projects

Tomorrow.io offers a free Developer tier that gives you access to core weather parameters: temperature, humidity, wind, precipitation, cloud cover, and related basic fields. The free forecast range covers up to 4.5 days ahead. You also get a small sample of air quality and pollen data, but not the full premium layers.

The free tier allows 500 requests per day, capped at 25 requests per hour and 3 requests per second. That is more generous than many competitors. You can poll a few locations regularly or query multiple endpoints for a small project without hitting the limit immediately.

There are important restrictions:

• First, the free tier does not include historical weather data. If you need past conditions, you must upgrade.
• Second, the forecast only reaches 4.5 days on the free tier, not the 14 days advertised on paid plans.
• Third, premium data layers such as full air quality, pollen, lightning, fire index, soil, solar, and maritime data require paid access.
• Fourth, and most importantly, the Terms of Service prohibit commercial use on self-generated free accounts. If you are building a business tool, a revenue-generating app, or an internal company dashboard, you cannot legally use the free tier. You must sign up for a paid plan.
• Finally, the Terms require you to display "Powered by Tomorrow.io" attribution wherever you show the data.

The API uses a simple REST interface with an API key. You can request real-time conditions and forecast timelines by latitude and longitude. The response format is JSON, and the docs provide examples in shell, Python, Node, Java, Go, and R.

Usage

Shell:

curl -s "https://api.tomorrow.io/v4/weather/realtime?location=42.3601,-71.0589&apikey=YOUR_API_KEY" -H "Accept: application/json" | python3 -m json.tool

Python:

import requests

url = "https://api.tomorrow.io/v4/timelines"
params = {
    "apikey": "YOUR_API_KEY",
    "location": "42.3601,-71.0589",
    "fields": ["temperature", "windSpeed"],
    "timesteps": "1d",
    "startTime": "now",
    "endTime": "now+5d"
}
response = requests.get(url, params=params, timeout=30)
response.raise_for_status()
data = response.json()
for interval in data["data"]["timelines"][0]["intervals"]:
    print(f"{interval['startTime']}: {interval['values']['temperature']} C")

What to check before you commit

• Commercial use is not allowed on the free tier. If your project has any business purpose, pay for a plan.
• Historical data is completely absent from the free tier.
• Forecasts are limited to 4.5 days. If you need a full week or two, look elsewhere or upgrade.
• Premium environmental layers (air quality, pollen, lightning, fire, soil, solar) are only samples or absent on the free tier.
• You must display "Powered by Tomorrow.io" attribution.
• Rate limits are 500/day, 25/hour, 3/second. That is enough for a hobby project but tight for anything ambitious.

Verdict

A solid free option for non-commercial projects that only need current conditions and short-range forecasts. The request quota is generous, but the commercial ban, missing historical data, and short forecast horizon are real limitations. Read the Terms before you build anything serious.

8. Meteomatics

Best for: Evaluating a high-parameter enterprise weather API before buying

Meteomatics is an enterprise-grade weather API with over 1,800 available parameters, including specialized fields for energy, agriculture, marine, and environmental use cases.

It offers historic, current, and forecast data globally through a flexible REST-style interface. You can request data by coordinates, stations, routes, or polygons, and receive responses in JSON, CSV, XML, NetCDF, PNG, and other formats.

Here is the catch: there is no permanent free tier. Meteomatics offers a 14-day free trial that is limited to basic weather parameters and lower-resolution data. After two weeks, you must pay. Pricing is custom-quoted and negotiated directly with sales; there are no self-service paid tiers. If you are looking for a free API to run continuously, this is not it.

The API uses HTTP Basic Auth with a username and password. The URL structure is unusual but consistent: api.meteomatics.com/<validdatetime>/<parameters>/<location>/<format>. For example, you can request temperature, precipitation, and wind speed for a specific coordinate pair in a single call. The docs also support advanced features like ensemble forecasts, route queries along a path, and polygon aggregations, though these may require higher-tier access.

The company's proprietary EURO1k model provides 1-kilometer resolution over Europe, but that requires at least the Professional tier. The free trial will not give you the full precision the platform is known for.

Usage

Shell:

curl -s -u "username:password" "https://api.meteomatics.com/2025-05-26T00:00:00Z--2025-05-26T04:00:00Z:PT1H/t_2m:C,precip_1h:mm,wind_speed_10m:ms/50,10/json" | python3 -m json.tool

Python:

import requests

url = "https://api.meteomatics.com/2025-05-26T00:00:00Z--2025-05-26T04:00:00Z:PT1H/t_2m:C,precip_1h:mm,wind_speed_10m:ms/50,10/json"
response = requests.get(url, auth=("username", "password"), timeout=30)
response.raise_for_status()
data = response.json()
print(data)

What to check before you commit

• The free offering is a 14-day trial, not an ongoing free plan. Do not build a long-term project around it.
• The trial is limited to basic parameters and lower-resolution data.
• You cannot sign up for a paid plan without talking to sales. There is no transparent self-service pricing.
• The high-resolution EURO1k model and advanced parameters require paid tiers.
• You can monitor your usage via the user_stats endpoint.
• The API uses username/password Basic Auth, not a simple API key.

Verdict

A powerful and flexible API for organizations that need deep weather data and have the budget for custom enterprise pricing. For individual developers or small projects looking for a free ongoing weather API, this is not the right choice. Use the 14-day trial only if you are seriously evaluating Meteomatics for a paid deployment.

Comparison Table

Table 1: Free Tier Quotas and Permissions

Table 2: Data Coverage and Practical Verdict

In summary,

• If you need historical data on a free tier: Visual Crossing is the clear winner (back to 1970). Open-Meteo also offers historical data without a key.
• If you need severe weather alerts on a free tier: NWS API is the only option, but it is US-only.
• If you need the highest free quota: WeatherAPI.com (100K/month) or NWS (unlimited).
• If you need global coverage without signing up: Open-Meteo.
• If you are building anything commercial: NWS API (US only), WeatherAPI.com, or OpenWeather (with attribution). The rest block commercial use on their free tiers.
• If you need enterprise depth: Meteomatics has the richest catalog, but you must pay after 14 days.

How to Choose the Right Weather API

The best weather API depends on how the data will be used. A small Bash script may only need current conditions and a simple JSON response. A dashboard or reporting tool may need historical data, forecasts, alerts, location search, and predictable rate limits.

Start with the response format. JSON is usually the easiest option for scripts that use curl and jq, while CSV can be useful for reports, spreadsheets, and quick terminal inspection. A good API should return data in a structure that feels easy to parse without extra cleanup.

Authentication and rate limits matter once a script runs automatically. A one-time test from the terminal is simple, but scheduled jobs require stable access, clear error messages, and limits that align with the project’s usage. The best APIs make these details easy to understand before deployment.

Developer experience is another practical factor. Weather APIs typically use HTTP requests, so projects that already follow REST API patterns are easier to test, debug, and integrate into Linux workflows.

Historical data can be just as important as forecasts. If the project compares past conditions, builds reports, analyzes travel or agricultural patterns, or checks weather impacts over time, choose an API that supports date ranges and maintains consistent historical records.

Coverage should match the project’s geography. A US-only API can be excellent for local tools, but global applications need international data coverage, timezone handling, and reliable location search. The right API is the one that fits the script’s actual job without adding unnecessary complexity.

Practical Ways to Use Weather APIs in Linux Projects

A weather API becomes more useful when it is tied to a real task. Linux users can test an endpoint with curl, inspect the response with jq, and save the output into a file for later processing. From there, the same data can feed scripts, dashboards, reports, or alerts.

One common use case is a small monitoring script. A server can request forecast data at scheduled intervals, extract values such as temperature, rain probability, wind speed, or severe weather alerts, and then send a notification when a threshold is met.

Weather APIs also work well in dashboards. A self-hosted dashboard can display current conditions, forecast summaries, or historical comparisons for a specific location. This is useful for homelab setups, local business tools, agricultural projects, travel-planning apps, and IoT systems.

Historical weather data opens up more advanced workflows. Developers can compare past conditions against sales, traffic, energy usage, crop performance, or outdoor event attendance. These projects need consistent date-based records, not only a simple forecast.

For automation, the best setup is usually simple. Keep API keys out of scripts when possible, store responses for debugging, handle failed requests cleanly, and log enough information to understand what happened during scheduled runs. A reliable weather script should fail clearly rather than silently produce bad data.

A Practical Pick for Weather-Based Linux Projects

Weather APIs are easiest to choose when the project goal is clear. A hobby dashboard may only need current conditions and a short forecast. A Bash script may need a simple JSON response that can be parsed quickly. A reporting workflow may need CSV output, historical records, and stable date-based queries.

For most Linux users and developers, the best option is the one that matches the workflow without adding extra setup:

• Open-Meteo works well for free and open-source experiments.
• OpenWeather and WeatherAPI.com are practical choices for general app development.
• The National Weather Service API is useful for US-focused public weather data. Weatherbit,
• Tomorrow.io, and Meteomatics make sense when a project needs alerts, operational data, or advanced weather variables.
• Visual Crossing is the strongest fit when historical data drives the project. Its free tier includes over 50 years of historical records alongside current conditions and forecasts, which makes it useful for scripts, dashboards, reports, and any workflow that compares past conditions or tracks trends over time.

Clean responses, useful documentation, sensible limits, and reliable data matter more than a long feature list. Choose the API that fits the script, test the response format, and keep the workflow simple enough to run reliably.