Introduction

Qanto unifies the world's weather data into a single, developer-friendly API.

The Problem

Getting comprehensive weather data today means juggling 5–10 different APIs, each with its own authentication, data format (GRIB2, NetCDF, GeoJSON, CSV, XML), rate limits, and quirks. A developer who wants current conditions, forecasts, and historical data must register with NOAA, ECMWF, NWS, Open-Meteo, and others — then write glue code to normalize everything into a usable format.

Enterprise weather intelligence providers like DTN and Tomorrow.io charge $50,000–$500,000/year and require sales conversations. Small teams, indie developers, and AI agents are locked out.

What Qanto Does

One API call. Clean JSON. Every major weather data source unified and normalized. Pay per call — no annual contracts, no salesperson.

Data Sources

SourceTypeResolutionLicense
NOAA GFSGlobal forecast28 kmPublic domain
ECMWF IFSGlobal forecast28 kmCC-BY-4.0
NOAA HRRRUS high-res forecast3 kmPublic domain
NWS APIUS forecasts + alerts2.5 kmPublic domain
ERA5Historical reanalysis31 kmCopernicus
Open-MeteoMulti-model aggregation1-11 kmCC-BY-4.0

Key Features

  • One API key for all weather data sources
  • Clean JSON responses — no GRIB, NetCDF, or XML
  • Current conditions, hourly forecasts, and daily summaries in a single call
  • Transparent source attribution on every data point
  • Metric and imperial unit support
  • AI model forecasts (ECMWF AIFS, NOAA AIGFS, NVIDIA Earth-2)
  • Historical reanalysis data back to 1940 via ERA5
  • x402 micropayments for AI agents — no account needed
  • 5-minute onboarding — signup to first successful call

Quick Start

From zero to working API call in under 5 minutes.

1. Get Your API Key

  1. Sign up at dashboard.qanto.com
  2. Navigate to Settings → API Keys
  3. Create a new key. You'll receive a key starting with sk_test_ (sandbox) or sk_live_ (production)

2. Make Your First Request

cURL
curl "https://api.qanto.com/v1/weather/london" \
  -H "Authorization: Bearer sk_test_YOUR_API_KEY"
Python
import requests

response = requests.get(
    "https://api.qanto.com/v1/weather/london",
    headers={"Authorization": "Bearer sk_test_YOUR_API_KEY"}
)

data = response.json()
print(f"Temperature: {data['current']['temperature_c']}°C")
print(f"Wind: {data['current']['wind_speed_ms']} m/s")
print(f"Conditions: {data['current']['weather_description']}")
JavaScript
const response = await fetch(
  "https://api.qanto.com/v1/weather/london",
  {
    headers: { Authorization: "Bearer sk_test_YOUR_API_KEY" },
  }
);

const data = await response.json();
console.log(`Temperature: ${data.current.temperature_c}°C`);
console.log(`Wind: ${data.current.wind_speed_ms} m/s`);
Go
package main

import (
    "encoding/json"
    "fmt"
    "net/http"
    "io"
)

func main() {
    req, _ := http.NewRequest("GET",
        "https://api.qanto.com/v1/weather/london", nil)
    req.Header.Set("Authorization", "Bearer sk_test_YOUR_API_KEY")

    resp, _ := http.DefaultClient.Do(req)
    defer resp.Body.Close()
    body, _ := io.ReadAll(resp.Body)

    var data map[string]interface{}
    json.Unmarshal(body, &data)
    fmt.Println(data)
}

3. Understanding the Response

Every response from the weather endpoint contains four top-level objects:

  • location— Resolved coordinates, name, elevation, and timezone
  • current— Latest observed conditions (temperature, wind, humidity, etc.)
  • hourly[]— Hourly forecast array (default 48 hours, max 384)
  • daily[]— Daily summary array (default 7 days, max 16)
  • meta— Credits used, models queried, generation timestamp

4. Customize Your Request

3-day forecast, imperial units
curl "https://api.qanto.com/v1/weather/new-york?days=3&units=imperial" \
  -H "Authorization: Bearer sk_test_YOUR_API_KEY"
Specific model, minimal fields
curl "https://api.qanto.com/v1/weather/40.71,-74.01?models=ecmwf&fields=temperature_c,wind_speed_ms" \
  -H "Authorization: Bearer sk_test_YOUR_API_KEY"
Extended 16-day forecast
curl "https://api.qanto.com/v1/weather/tokyo?days=16&hours=384" \
  -H "Authorization: Bearer sk_test_YOUR_API_KEY"

Authentication

All API requests require a Bearer token in the Authorization header.

Request Format

Authorization: Bearer sk_live_YOUR_API_KEY

Include this header in every request to the Qanto API.

Key Types

PrefixEnvironmentRate LimitBilling
sk_test_Sandbox10 requests/secFree (limited data)
sk_live_ProductionPer plan (2–100/sec)Metered billing

Error Responses

Missing key (401):

{
  "error": {
    "code": "UNAUTHORIZED",
    "message": "Missing or invalid Authorization header. Expected: Bearer sk_live_...",
    "docs": "https://docs.qanto.com/authentication"
  }
}

Invalid key (401):

{
  "error": {
    "code": "INVALID_API_KEY",
    "message": "The provided API key is invalid or has been revoked.",
    "docs": "https://docs.qanto.com/authentication"
  }
}

Security Best Practices

  • Never expose API keys in client-side code or public repositories
  • Use environment variables (QUANTARA_API_KEY) to store keys
  • Use sk_test_ keys during development, sk_live_ in production
  • Rotate keys regularly from the dashboard
  • Set IP allowlists for production keys when possible
  • Use separate keys for different applications or environments
  • Monitor usage in the dashboard to detect unauthorized access