How to Build a 5-Day Weather Dashboard in Python (Free API)

Athar Ahmad — Tue, 24 Feb 2026 08:10:00 +0000

In this tutorial you’ll build a real terminal weather dashboard — with forecasts, humidity, wind speed, and emoji weather icons — using Python and a free weather API. No experience needed.

What You’ll Build

By the end of this tutorial, you’ll have a working Python script that:

Shows current weather conditions for any city in the world
Displays a 5-day forecast in a clean table format
Includes temperature, humidity, wind speed, rain chance, and weather icons
Accepts any city as a command-line argument
Takes about 20 minutes to complete

Here’s what the output looks like:

──────────────────────────────────────────────────
📍 London, United Kingdom — Right Now
──────────────────────────────────────────────────
⛅ Partly Cloudy
🌡 Temperature : 14°C / 57°F (Feels like 12°C)
💧 Humidity : 78%
💨 Wind : 15 mph SW
👁 Visibility : 10 km
☀ UV Index : 2
──────────────────────────────────────────────────

📅 Forecast

Date Conditions High Low Rain%
─────────────────────────────────────────────────────────────
Mon 24 Feb ⛅ Partly Cloudy 14°C 9°C 20%
Tue 25 Feb 🌧 Light Rain 11°C 7°C 85%
Wed 26 Feb ☁ Overcast 12°C 8°C 40%
Thu 27 Feb ☀ Sunny 16°C 9°C 5%
Fri 28 Feb ⛅ Partly Cloudy 15°C 10°C 15%

What You’ll Need

Python 3.8 or newer — download here if you don’t have it
A free API key from World Weather Online — takes 2 minutes to get, no credit card needed
A code editor — VS Code is great if you don’t have one

That’s it. Let’s go.

Step 1 — Get Your Free API Key

First, you need an API key. Think of it like a password that lets your code talk to the weather service.

Go to worldweatheronline.com/weather-api
Click Sign Up Free
Fill in your name and email address
Check your inbox and click the confirmation link
Log in and copy your API key from the dashboard

Keep this key handy — you’ll need it in Step 4. The free plan gives you 500 API calls per day , which is more than enough for learning and personal projects.

Step 2 — Install the Required Libraries

We need two Python libraries:

requests — makes it easy to call web APIs
rich — makes our terminal output look beautiful (this one is optional but makes a big difference)

Open your terminal (or Command Prompt on Windows) and run:

pip install requests rich

If you’re on a Mac and get a permission error, try:

pip3 install requests rich

To check they installed correctly:

python -c "import requests, rich; print('All good!')"

You should see All good! printed. If you see an error, make sure you’re using the same Python version you just installed the packages for.

Step 3 — Create Your Project File

Create a new folder on your computer called weather-dashboard, then inside it create a file called weather.py.

Your folder should look like this:

weather-dashboard/
└── weather.py

Open weather.py in your code editor and leave it empty for now — we’ll fill it in as we go.

Step 4 — Set Up Your API Key Safely

Important: Never paste your API key directly into your code, especially if you plan to share it on GitHub. Instead, we store it as an environment variable — a value your computer holds in memory, separate from your code.

On Mac/Linux , open your terminal and run:

export WWO_API_KEY="paste_your_key_here"

On Windows (Command Prompt), run:

set WWO_API_KEY=paste_your_key_here

On Windows (PowerShell), run:

$env:WWO_API_KEY="paste_your_key_here"

Note: You’ll need to run this command each time you open a new terminal window. To make it permanent, add it to your .bashrc or .zshrc file on Mac/Linux, or set it in System Environment Variables on Windows.

Now let’s read it in Python. Add this to the top of your weather.py:

import os

API_KEY = os.environ.get("WWO_API_KEY", "your_api_key_here")

This line checks for your environment variable. If it doesn’t find one, it falls back to the text "your_api_key_here" — which our script will detect and show a helpful error message for.

Step 5 — Make Your First API Call

Now the fun part. Let’s fetch some weather data.

The World Weather Online API works like this: you send it a web request with your location and API key, and it sends back JSON data (a structured text format) with all the weather information.

Add this to your weather.py:

import requests
import os

API_KEY = os.environ.get("WWO_API_KEY", "your_api_key_here")
BASE_URL = "https://api.worldweatheronline.com/premium/v1/weather.ashx"

def get_weather(location, days=5):
    """Fetch weather data from the API."""

    params = {
        "key": API_KEY,
        "q": location, # city name or "lat,lon" coordinates
        "format": "json", # we want JSON back, not XML
        "num_of_days": days, # how many days of forecast
        "tp": 24, # 24-hour intervals (daily summary)
        "includelocation": "yes", # include the matched location name
        "cc": "yes", # include current conditions
    }

    response = requests.get(BASE_URL, params=params)
    data = response.json()
    return data["data"]

# Test it!
weather = get_weather("London")
print(weather["current_condition"][0]["temp_C"], "°C")

Run it with:

python weather.py

If everything is working, you’ll see the current temperature in London printed to the screen — something like 14 °C.

What just happened?

We built a URL with your API key and location attached
requests.get() sent that URL to the World Weather Online server
The server sent back a big chunk of JSON data
.json() converted that into a Python dictionary
We dug into data["current_condition"][0]["temp_C"] to get the temperature

Step 6 — Understand the API Response

Before we build the dashboard, let’s understand what data the API gives us. Add this temporarily to see the full response:

import json
weather = get_weather("London")
print(json.dumps(weather, indent=2))

You’ll see something like this (shortened):

{
  "current_condition": [
    {
      "temp_C": "14",
      "temp_F": "57",
      "FeelsLikeC": "12",
      "humidity": "78",
      "windspeedMiles": "15",
      "winddir16Point": "SW",
      "uvIndex": "2",
      "visibility": "10",
      "weatherDesc": [{ "value": "Partly Cloudy" }]
    }
  ],
  "weather": [
    {
      "date": "2026-02-24",
      "maxtempC": "14",
      "mintempC": "9",
      "hourly": [
        {
          "weatherDesc": [{ "value": "Partly Cloudy" }],
          "chanceofrain": "20",
          "windspeedMiles": "15"
        }
      ]
    }
  ],
  "nearest_area": [
    {
      "areaName": [{ "value": "London" }],
      "country": [{ "value": "United Kingdom" }]
    }
  ]
}

The structure has three main parts:

current_condition — what the weather is like right now
weather — an array of daily forecasts (one per day)
nearest_area — the location the API matched to your query

Delete the debug print and let’s build the display.

Step 7 — Add Weather Icons

Weather is visual — let’s make our output feel that way. We’ll map common weather descriptions to emojis:

WEATHER_ICONS = {
    "sunny": "☀",
    "clear": "🌙",
    "partly cloudy": "⛅",
    "cloudy": "☁",
    "overcast": "☁",
    "mist": "🌫",
    "fog": "🌫",
    "rain": "🌧",
    "drizzle": "🌦",
    "snow": "❄",
    "sleet": "🌨",
    "thunder": "⛈",
    "blizzard": "🌨",
}

def get_icon(description):
    """Return an emoji for a weather description."""
    desc = description.lower()
    for keyword, icon in WEATHER_ICONS.items():
        if keyword in desc:
            return icon
    return "🌡" # default if nothing matches

The function lowercases the description and checks if any of our keywords appear in it. So "Light rain showers" will match "rain" and return .

Step 8 — Display Current Conditions

Now let’s build the function that shows the current weather panel:

def display_current(current, location_name):
    """Print current weather conditions."""

    desc = current["weatherDesc"][0]["value"]
    icon = get_icon(desc)
    temp_c = current["temp_C"]
    temp_f = current["temp_F"]
    feels = current["FeelsLikeC"]
    humid = current["humidity"]
    wind = current["windspeedMiles"]
    wdir = current["winddir16Point"]
    uv = current["uvIndex"]
    vis = current["visibility"]

    print("\n" + "─" * 50)
    print(f"📍 {location_name} — Right Now")
    print("─" * 50)
    print(f"{icon} {desc}")
    print(f"🌡 Temperature : {temp_c}°C / {temp_f}°F (Feels like {feels}°C)")
    print(f"💧 Humidity : {humid}%")
    print(f"💨 Wind : {wind} mph {wdir}")
    print(f"👁 Visibility : {vis} km")
    print(f"☀ UV Index : {uv}")
    print("─" * 50)

What’s happening here?

current["weatherDesc"][0]["value"] — the description is nested inside a list and a dictionary, so we dig into it with [0]["value"]
We use Python f-strings (the f"..." strings) to neatly slot variables into our text
"─" * 50 repeats the dash character 50 times to make a dividing line

Step 9 — Display the Forecast Table

Now for the 5-day forecast:

from datetime import datetime

def display_forecast(weather_days):
    """Print a multi-day forecast table."""

    print("\n📅 Forecast\n")
    print(f"{'Date':<14} {'Conditions':<25} {'High':>7} {'Low':>7} {'Rain%':>7} {'Wind':>7}")
    print("─" * 75)

    for day in weather_days:
        # Format the date nicely: "Mon 24 Feb"
        date_obj = datetime.strptime(day["date"], "%Y-%m-%d")
        date_fmt = date_obj.strftime("%a %d %b")

        # Get the condition description and icon
        desc = day["hourly"][0]["weatherDesc"][0]["value"]
        icon = get_icon(desc)

        # Get temperatures and other stats
        max_c = day["maxtempC"]
        min_c = day["mintempC"]
        rain = day["hourly"][0].get("chanceofrain", "N/A")
        wind = day["hourly"][0]["windspeedMiles"]

        print(f"{date_fmt:<14} {icon+' '+desc:<25} {max_c+'°C':>7} {min_c+'°C':>7} {rain+'%':>7} {wind:>7}")

    print("─" * 75)

Things to notice:

f"{'Date':<14}" — the :<14 part left-aligns the text in a column 14 characters wide. :>7 right-aligns in 7 characters. This keeps everything lined up neatly.
datetime.strptime(day["date"], "%Y-%m-%d") — converts the date string "2026-02-24" into a Python date object
.strftime("%a %d %b") — formats it back as "Mon 24 Feb"
.get("chanceofrain", "N/A") — safely gets rain chance, defaulting to “N/A” if it’s missing

Step 10 — Add Error Handling

Good code handles things going wrong gracefully. What if someone types a city that doesn’t exist? What if the internet is down?

Replace your get_weather function with this improved version:

def get_weather(location, days=5):
    """Fetch weather data with error handling."""

    if API_KEY == "your_api_key_here":
        print("❌ Please set your API key!")
        print(" Run: export WWO_API_KEY='your_key_here'")
        print(" Get a free key: https://www.worldweatheronline.com/weather-api/")
        return None

    params = {
        "key": API_KEY, "q": location, "format": "json",
        "num_of_days": days, "tp": 24, "includelocation": "yes", "cc": "yes",
    }

    try:
        response = requests.get(BASE_URL, params=params, timeout=10)
        response.raise_for_status()
        data = response.json()

        if "error" in data.get("data", {}):
            print(f"❌ API Error: {data['data']['error'][0]['msg']}")
            return None

        return data["data"]

    except requests.exceptions.ConnectionError:
        print("❌ No internet connection. Please check your network.")
    except requests.exceptions.Timeout:
        print("❌ The request timed out. Please try again.")
    except requests.exceptions.HTTPError as e:
        print(f"❌ HTTP Error: {e}")

    return None

What’s new:

timeout=10 — if the API doesn’t respond in 10 seconds, we give up cleanly
raise_for_status() — raises an error if the server returns a 4xx or 5xx status code
try/except blocks — catch specific errors and show friendly messages instead of a crash

Step 11 — Tie It All Together

Now let’s add the main block that runs everything. Add this at the bottom of your file:

import argparse

def main():
    # Set up command-line arguments
    parser = argparse.ArgumentParser(description="World Weather Online — Terminal Dashboard")
    parser.add_argument("--location", "-l", default="London",
                        help="City name or coordinates (default: London)")
    parser.add_argument("--days", "-d", type=int, default=5,
                        help="Number of forecast days, 1-7 (default: 5)")
    args = parser.parse_args()

    print(f"\n🌍 Fetching weather for {args.location}...")

    data = get_weather(args.location, args.days)
    if not data:
        return # Error was already printed inside get_weather

    # Get the matched location name from the API
    try:
        area = data["nearest_area"][0]["areaName"][0]["value"]
        country = data["nearest_area"][0]["country"][0]["value"]
        location_name = f"{area}, {country}"
    except (KeyError, IndexError):
        location_name = args.location # fall back to what the user typed

    display_current(data["current_condition"][0], location_name)
    display_forecast(data["weather"])

    print("\nData by World Weather Online — https://www.worldweatheronline.com\n")

if __name__ == " __main__":
    main()

The if __name__ == " __main__": line means “only run main() if this file is being run directly” — a Python best practice.

Step 12 — Run Your Dashboard!

Save the file and run:

# Default (London, 5 days)
python weather.py

# Choose a city
python weather.py --location "Tokyo"
python weather.py --location "New York"
python weather.py -l Paris

# Choose number of days (1-7)
python weather.py -l Sydney -d 3

# Works with coordinates too
python weather.py -l "51.5,-0.1"

You should see your full weather dashboard in the terminal!

Bonus: Make It Even Prettier with Rich

The rich library we installed earlier makes terminal output look really polished. Here’s how to add it:

from rich.console import Console
from rich.table import Table
from rich.panel import Panel
from rich import box

console = Console()

def display_current_rich(current, location_name):
    """Fancy version using rich."""
    desc = current["weatherDesc"][0]["value"]
    icon = get_icon(desc)

    content = (
        f"[bold]{icon} {desc}[/bold]\n\n"
        f"🌡 Temperature : [bold cyan]{current['temp_C']}°C[/bold cyan] / "
        f"{current['temp_F']}°F (Feels like {current['FeelsLikeC']}°C)\n"
        f"💧 Humidity : {current['humidity']}%\n"
        f"💨 Wind : {current['windspeedMiles']} mph {current['winddir16Point']}\n"
        f"👁 Visibility : {current['visibility']} km\n"
        f"☀ UV Index : {current['uvIndex']}"
    )

    console.print(Panel(
        content,
        title=f"[bold yellow]📍 {location_name} — Right Now[/bold yellow]",
        border_style="blue"
    ))

Rich uses tags like [bold], [cyan], and [bold yellow] to add colour and style — similar to HTML but for the terminal.

The Complete Script

Here’s the full weather.py all in one place, ready to copy and run:

import requests
import argparse
import os
from datetime import datetime

API_KEY = os.environ.get("WWO_API_KEY", "your_api_key_here")
BASE_URL = "https://api.worldweatheronline.com/premium/v1/weather.ashx"

WEATHER_ICONS = {
    "sunny": "☀", "clear": "🌙", "partly cloudy": "⛅",
    "cloudy": "☁", "overcast": "☁", "mist": "🌫",
    "fog": "🌫", "rain": "🌧", "drizzle": "🌦",
    "snow": "❄", "sleet": "🌨", "thunder": "⛈", "blizzard": "🌨",
}

def get_icon(description):
    desc = description.lower()
    for keyword, icon in WEATHER_ICONS.items():
        if keyword in desc:
            return icon
    return "🌡"

def get_weather(location, days=5):
    if API_KEY == "your_api_key_here":
        print("❌ Set your API key: export WWO_API_KEY='your_key'")
        print(" Get one free: https://www.worldweatheronline.com/weather-api/")
        return None
    params = {
        "key": API_KEY, "q": location, "format": "json",
        "num_of_days": days, "tp": 24, "includelocation": "yes", "cc": "yes",
    }
    try:
        r = requests.get(BASE_URL, params=params, timeout=10)
        r.raise_for_status()
        data = r.json().get("data", {})
        if "error" in data:
            print(f"❌ {data['error'][0]['msg']}")
            return None
        return data
    except requests.exceptions.ConnectionError:
        print("❌ No internet connection.")
    except requests.exceptions.Timeout:
        print("❌ Request timed out.")
    return None

def display_current(current, location_name):
    desc = current["weatherDesc"][0]["value"]
    icon = get_icon(desc)
    print("\n" + "─" * 50)
    print(f"📍 {location_name} — Right Now")
    print("─" * 50)
    print(f"{icon} {desc}")
    print(f"🌡 Temperature : {current['temp_C']}°C / {current['temp_F']}°F (Feels like {current['FeelsLikeC']}°C)")
    print(f"💧 Humidity : {current['humidity']}%")
    print(f"💨 Wind : {current['windspeedMiles']} mph {current['winddir16Point']}")
    print(f"👁 Visibility : {current['visibility']} km")
    print(f"☀ UV Index : {current['uvIndex']}")
    print("─" * 50)

def display_forecast(weather_days):
    print("\n📅 Forecast\n")
    print(f"{'Date':<14} {'Conditions':<25} {'High':>7} {'Low':>7} {'Rain%':>7} {'Wind':>7}")
    print("─" * 75)
    for day in weather_days:
        date_fmt = datetime.strptime(day["date"], "%Y-%m-%d").strftime("%a %d %b")
        desc = day["hourly"][0]["weatherDesc"][0]["value"]
        icon = get_icon(desc)
        rain = day["hourly"][0].get("chanceofrain", "N/A")
        wind = day["hourly"][0]["windspeedMiles"]
        print(f"{date_fmt:<14} {icon+' '+desc:<25} {day['maxtempC']+'°C':>7} {day['mintempC']+'°C':>7} {rain+'%':>7} {wind:>7}")
    print("─" * 75)

def main():
    parser = argparse.ArgumentParser(description="World Weather Online — Terminal Dashboard")
    parser.add_argument("--location", "-l", default="London")
    parser.add_argument("--days", "-d", type=int, default=5)
    args = parser.parse_args()

    print(f"\n🌍 Fetching weather for {args.location}...")
    data = get_weather(args.location, args.days)
    if not data:
        return

    try:
        area = data["nearest_area"][0]["areaName"][0]["value"]
        country = data["nearest_area"][0]["country"][0]["value"]
        location_name = f"{area}, {country}"
    except (KeyError, IndexError):
        location_name = args.location

    display_current(data["current_condition"][0], location_name)
    display_forecast(data["weather"])
    print("\nData by World Weather Online — https://www.worldweatheronline.com\n")

if __name__ == " __main__":
    main()

What You Learned

In this tutorial you:

Made your first call to a real REST API using Python
Worked with JSON data and navigated nested dictionaries
Used f-strings and string formatting to create aligned tables
Added error handling so your script fails gracefully
Used argparse to accept command-line arguments
Stored secrets safely using environment variables

What to Try Next

Now that you have a working dashboard, here are some ideas to extend it:

Export to CSV — add import csv and write the forecast data to a file
Email alerts — send yourself a morning weather summary using Python’s smtplib
Multiple cities — loop over a list of cities and compare them side by side
Historical data — use the Historical Weather API to analyse past weather trends
Marine forecasts — swap to the Marine API for wave height and tide data

Get Your Free API Key

Everything in this tutorial works on the free plan — 500 API calls per day, no credit card required.

Sign up free at worldweatheronline.com/weather-api

Have questions or got stuck? Drop a comment below — I’ll help you out.

Tags: python beginners api weather tutorial programming

The post How to Build a 5-Day Weather Dashboard in Python (Free API) appeared first on Weather Blog.

DEV Community: Athar Ahmad