Storm Glass

Overview

Storm Glass offers a specialized weather and environmental data API designed primarily for marine applications. The API provides access to global forecast and historical data for a comprehensive set of parameters relevant to ocean and coastal environments. This includes metrics such as wave height, wave direction, swell components, wind speed and direction, air temperature, sea temperature, and precipitation. The service is structured to support developers building applications that require precise and localized marine weather intelligence.

The API is particularly suited for use cases involving marine navigation, recreational boating, professional fishing, and surfing. For instance, developers can integrate Storm Glass data to create real-time surf forecasting apps that display wave conditions and optimal surfing times, or to build sailing planners that account for wind patterns and currents along specific routes. The historical data capabilities allow for analysis of past weather conditions, which can be valuable for research, risk assessment, or optimizing operational strategies based on recurring patterns.

Storm Glass differentiates itself by focusing specifically on marine conditions, providing granular data that might be less prominent in general weather APIs. The API covers global locations, ensuring that developers can access relevant data regardless of their target geographic area. Data is presented in a consistent JSON format, facilitating parsing and integration into various programming environments. With available SDKs for Python and Node.js, and comprehensive documentation, the developer experience is designed for straightforward implementation. The platform aims to provide reliable data for critical decision-making in marine-dependent industries and activities.

Compared to broader weather APIs like OpenWeather's API documentation, Storm Glass emphasizes oceanographic parameters, making it a targeted solution for marine-specific projects. Its data includes detailed wave spectrum information, which is crucial for applications where wave dynamics are a primary concern. The API's forecast models extend up to several days, offering predictive capabilities for short to medium-term planning. Historical data archives provide information for retrospective analysis and model validation. This focus enables developers to build highly specialized and accurate applications for users who rely on precise marine environmental information.

Key features

• Marine Weather API: Provides real-time and forecast data for oceanographic parameters including wave height, period, direction, swell components, wind speed, and temperature.
• Global Coverage: Offers weather data for any location worldwide, supporting applications with international reach.
• Historical Weather Data: Access to past weather conditions, enabling retrospective analysis, trend identification, and model validation.
• High-Resolution Data: Delivers localized data points for precise environmental monitoring and forecasting.
• Multiple Data Parameters: Supports a wide range of weather and ocean parameters, including air temperature, sea temperature, precipitation, cloud cover, and UV index.
• Developer SDKs: Provides client libraries for Python and Node.js to simplify API integration and reduce development time.
• Data Format: Delivers data in a standardized JSON format, compatible with most programming languages and frameworks.
• GDPR Compliance: Adheres to General Data Protection Regulation (GDPR) standards for data privacy and security.

Pricing

Storm Glass offers a free developer plan and multiple paid tiers based on request volume. The pricing structure is designed to scale with usage, from individual projects to commercial applications. As of 2026-05-28, the pricing details are:

For the most current pricing information, refer to the official Storm Glass pricing page.

Common integrations

Storm Glass API can be integrated into various applications and platforms requiring marine weather data. Common integration scenarios include:

• Web Applications: Displaying real-time surf forecasts or sailing conditions on websites using JavaScript and frontend frameworks.
• Mobile Applications: Powering native iOS or Android apps with localized weather data for fishermen, surfers, or boaters.
• IoT Devices: Connecting to marine sensors or smart buoys to provide contextual weather data for environmental monitoring systems.
• Data Analytics Platforms: Ingesting historical weather data for analysis, machine learning models, and generating insights into maritime trends.
• Geographic Information Systems (GIS): Overlaying weather data on maps using platforms like ArcGIS for spatial analysis of marine environments.
• Logistics and Shipping Systems: Integrating weather forecasts to optimize shipping routes, predict delays, and enhance safety for maritime transport.

Alternatives

• OpenWeather: Provides a broad range of weather data APIs, including current weather, forecasts, and historical data, with a focus on general atmospheric conditions.
• Tomorrow.io: Offers weather intelligence solutions with hyper-local, minute-by-minute forecasts and a focus on business applications across various industries.
• AccuWeather: Delivers global weather forecasts and historical data, serving a wide array of consumer and business needs with detailed meteorological information.

Getting started

To begin using the Storm Glass API, you first need to sign up for an account on their website to obtain an API key. Once you have your key, you can make requests to the API endpoints. The following example demonstrates how to fetch marine weather data for a specific location using the Python SDK.

This example retrieves wave height, wind speed, and air temperature for a coordinate near Santa Cruz, California, for a specific time. You would replace YOUR_API_KEY with your actual key obtained from the Storm Glass dashboard.

import requests
import datetime

api_key = "YOUR_API_KEY"
lat = 36.96
lng = -122.02

# Define parameters to retrieve
params = ['waveHeight', 'windSpeed', 'airTemperature']

# Define a specific point in time for the forecast (e.g., 6 hours from now)
# For historical data, specify a past datetime.
end_datetime = datetime.datetime.utcnow() + datetime.timedelta(hours=6)
start_datetime = datetime.datetime.utcnow()

# Format datetimes to ISO 8601 for the API request
start_iso = start_datetime.isoformat(timespec='seconds') + 'Z'
end_iso = end_datetime.isoformat(timespec='seconds') + 'Z'

# Construct the API request URL
# The 'source' parameter can be used to specify data sources, e.g., 'noaa'
request_url = (
    f"https://api.stormglass.io/v2/weather/point?lat={lat}&lng={lng}"
    f"¶ms={','.join(params)}&start={start_iso}&end={end_iso}"
)

headers = {
    'Authorization': api_key
}

try:
    response = requests.get(request_url, headers=headers)
    response.raise_for_status() # Raise an HTTPError for bad responses (4xx or 5xx)
    data = response.json()

    if data and 'hours' in data and data['hours']:
        # Access the first available hour of data
        first_hour_data = data['hours'][0]
        print(f"Weather data for {first_hour_data['time']}:")
        for param in params:
            # Each parameter might have multiple data sources (e.g., 'noaa', 'sg')
            # We'll just pick the first available source value for simplicity.
            if param in first_hour_data and first_hour_data[param]:
                source_value = list(first_hour_data[param].values())[0]
                print(f"  {param}: {source_value}")
            else:
                print(f"  {param}: Data not available")
    else:
        print("No weather data found for the specified time and location.")

except requests.exceptions.HTTPError as e:
    print(f"HTTP error occurred: {e}")
    print(f"Response content: {response.text}")
except requests.exceptions.RequestException as e:
    print(f"Request error occurred: {e}")
except Exception as e:
    print(f"An unexpected error occurred: {e}")

This Python script uses the requests library to make an HTTP GET request to the Storm Glass API. It includes basic error handling and demonstrates how to parse the JSON response to extract specific weather parameters. For detailed API reference and further examples, consult the Storm Glass API documentation.