Weather API for Mobile Apps: iOS, Android & Cross-Platform

By /

Weather API for Mobile Apps: Developer’s Complete Integration Guide

Mobile weather apps are among the most downloaded applications worldwide, with billions of users checking forecasts daily. Whether you’re building a standalone weather app, integrating weather features into existing apps, or creating weather-aware experiences, choosing the right weather API is crucial for success.

Essential Features for Mobile Weather APIs

When evaluating weather APIs for mobile development, prioritize these critical features:

  • Low latency response times — WeatherAPI averages ~200ms globally
  • Comprehensive location coverage — 4M+ locations across 200+ countries
  • Multiple data endpoints — current, forecast, historical, and specialized data
  • Flexible authentication — simple API key parameter
  • Generous free tier — 100,000 calls/month without credit card
  • JSON and XML support — native mobile parsing

Native iOS Integration with Swift

iOS apps benefit from WeatherAPI’s straightforward integration. Here’s a complete Swift implementation:

import Foundation

class WeatherService {
    private let apiKey = "YOUR_API_KEY"
    private let baseURL = "https://api.weatherapi.com/v1"
    
    func getCurrentWeather(for location: String, completion: @escaping (WeatherData?) -> Void) {
        let urlString = "\(baseURL)/current.json?key=\(apiKey)&q=\(location)&aqi=yes"
        guard let url = URL(string: urlString.addingPercentEncoding(withAllowedCharacters: .urlQueryAllowed) ?? "") else {
            completion(nil)
            return
        }
        
        URLSession.shared.dataTask(with: url) { data, response, error in
            guard let data = data, error == nil else {
                completion(nil)
                return
            }
            
            do {
                let weather = try JSONDecoder().decode(WeatherResponse.self, from: data)
                DispatchQueue.main.async {
                    completion(weather.current)
                }
            } catch {
                print("Decoding error: \(error)")
                completion(nil)
            }
        }.resume()
    }
}

struct WeatherResponse: Codable {
    let current: WeatherData
    let location: LocationData
}

struct WeatherData: Codable {
    let tempC: Double
    let condition: WeatherCondition
    let windKph: Double
    let humidity: Int
    let uv: Double
    
    enum CodingKeys: String, CodingKey {
        case tempC = "temp_c"
        case condition
        case windKph = "wind_kph"
        case humidity
        case uv
    }
}

Android Integration with Kotlin

Android developers can leverage WeatherAPI with Retrofit for efficient networking:

// WeatherAPI interface
interface WeatherApiService {
    @GET("current.json")
    suspend fun getCurrentWeather(
        @Query("key") apiKey: String,
        @Query("q") location: String,
        @Query("aqi") includeAqi: String = "yes"
    ): WeatherResponse
    
    @GET("forecast.json")
    suspend fun getForecast(
        @Query("key") apiKey: String,
        @Query("q") location: String,
        @Query("days") days: Int,
        @Query("aqi") includeAqi: String = "yes",
        @Query("alerts") includeAlerts: String = "yes"
    ): ForecastResponse
}

// Repository implementation
class WeatherRepository {
    private val apiService = RetrofitClient.weatherApiService
    private val apiKey = "YOUR_API_KEY"
    
    suspend fun getCurrentWeather(location: String): Result<WeatherResponse> {
        return try {
            val response = apiService.getCurrentWeather(apiKey, location)
            Result.success(response)
        } catch (e: Exception) {
            Result.failure(e)
        }
    }
    
    suspend fun getWeatherForecast(location: String, days: Int = 3): Result<ForecastResponse> {
        return try {
            val response = apiService.getForecast(apiKey, location, days)
            Result.success(response)
        } catch (e: Exception) {
            Result.failure(e)
        }
    }
}

Cross-Platform Development with React Native

React Native developers can create unified weather experiences across iOS and Android:

import React, { useState, useEffect } from 'react';
import { View, Text, ActivityIndicator } from 'react-native';

const WeatherAPI_KEY = 'YOUR_API_KEY';
const BASE_URL = 'https://api.weatherapi.com/v1';

const WeatherComponent = ({ location }) => {
  const [weather, setWeather] = useState(null);
  const [loading, setLoading] = useState(true);
  const [error, setError] = useState(null);

  useEffect(() => {
    fetchWeather();
  }, [location]);

  const fetchWeather = async () => {
    try {
      setLoading(true);
      const response = await fetch(
        `${BASE_URL}/current.json?key=${WeatherAPI_KEY}&q=${location}&aqi=yes`
      );
      
      if (!response.ok) {
        throw new Error(`HTTP error! status: ${response.status}`);
      }
      
      const data = await response.json();
      setWeather(data);
      setError(null);
    } catch (err) {
      setError(err.message);
      setWeather(null);
    } finally {
      setLoading(false);
    }
  };

  if (loading) return <ActivityIndicator size="large" />;
  if (error) return <Text>Error: {error}</Text>;
  if (!weather) return <Text>No weather data</Text>;

  return (
    <View>
      <Text>{weather.location.name}</Text>
      <Text>{weather.current.temp_c}°C</Text>
      <Text>{weather.current.condition.text}</Text>
      <Text>UV Index: {weather.current.uv}</Text>
    </View>
  );
};

export default WeatherComponent;

Mobile-Specific Optimization Tips

Optimize your mobile weather integration with these proven strategies:

  • Implement smart caching — cache responses for 10-15 minutes to reduce API calls
  • Handle offline scenarios — store last known weather data locally
  • Use location services — integrate with auto:ip for automatic location detection
  • Batch requests efficiently — combine current + forecast calls when possible
  • Optimize for different screen sizes — responsive design for tablets and phones
  • Background updates — refresh weather data when app becomes active

Advanced Mobile Features

WeatherAPI offers specialized endpoints perfect for mobile apps:

  • Weather alerts — government-issued warnings via /alerts.json
  • Air quality data — PM2.5, PM10, CO, NO2, SO2, O3 readings
  • Marine conditions — wave height, water temperature for coastal apps
  • Astronomy data — sunrise, sunset, moon phases for outdoor activities
  • Sports events — weather impact on sporting events

Get Started Today

Ready to integrate weather intelligence into your mobile app? Sign up for WeatherAPI and get 100,000 free API calls monthly — no credit card required. With comprehensive documentation, multiple SDKs, and reliable global infrastructure, WeatherAPI powers weather features for 850,000+ developers worldwide.

Scroll to Top