Weather

Documentation

Welcome to our API Documentation! Our API provides real-time weather information for cities around the world. You can use our API to retrieve data such as temperature, humidity, wind speed, and more. Below, we provide examples in various programming languages to show how you can interact with our API to get weather information for any city. Each example demonstrates how to make a request to our API and handle the response.

Endpoint

The base URL for accessing weather information is:

https://skyweather.pages.dev/?city=Mogadishu

To use our API, simply make a GET request to the previous API key by replacing {Mogadishu} with the name of the city you want to get weather data for. The response will include details like temperature, humidity, weather conditions, and more. Below are code examples in different programming languages that illustrate how to use our API effectively.

import requests

def get_weather(city):
    response = requests.get(f'https://skyweather.pages.dev/?city={city}')
    return response.json()

print(get_weather('Mogadishu'))

import axios from 'axios';

async function getWeather(city: string) {
    const response = await axios.get(`https://skyweather.pages.dev/?city=${city}`);
    return response.data;
}

getWeather('Mogadishu').then(console.log);

import Foundation

func getWeather(city: String, completion: @escaping (Data?) -> Void) {
    let url = URL(string: "https://skyweather.pages.dev/?city=\(city)")!
    let task = URLSession.shared.dataTask(with: url) { data, response, error in
        completion(data)
    }
    task.resume()
}

getWeather(city: "Mogadishu") { data in
    if let data = data {
        print(String(data: data, encoding: .utf8)!)
    }
}

require 'net/http'
require 'json'

def get_weather(city)
    uri = URI("https://skyweather.pages.dev/?city=#{city}")
    response = Net::HTTP.get(uri)
    JSON.parse(response)
end

puts get_weather('Mogadishu')

import java.net.HttpURLConnection
import java.net.URL

fun getWeather(city: String): String {
    val url = URL("https://skyweather.pages.dev/?city=$city")
    val connection = url.openConnection() as HttpURLConnection
    return connection.inputStream.bufferedReader().readText()
}

fun main() {
    println(getWeather("Mogadishu"))
}

use reqwest;

async fn get_weather(city: &str) -> reqwest::Result
								
								
								
								 {
    let url = format!("https://skyweather.pages.dev/?city={}", city);
    let response = reqwest::get(&url).await?.text().await?;
    Ok(response)
}

#[tokio::main]
async fn main() {
    match get_weather("Mogadishu").await {
        Ok(body) => println!("{}", body),
        Err(e) => eprintln!("Error: {}", e),
    }
}

package main

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

func getWeather(city string) (map[string]interface{}, error) {
    resp, err := http.Get(fmt.Sprintf("https://skyweather.pages.dev/?city=%s", city))
    if err != nil {
        return nil, err
    }
    defer resp.Body.Close()

    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        return nil, err
    }

    var result map[string]interface{}
    json.Unmarshal(body, &result)
    return result, nil
}

func main() {
    weather, err := getWeather("Mogadishu")
    if err != nil {
        fmt.Println("Error:", err)
        return
    }
    fmt.Println(weather)
}

import 'dart:convert';
import 'package:http/http.dart' as http;

Future
								
								
								
								 getWeather(String city) async {
    final response = await http.get(Uri.parse('https://skyweather.pages.dev/?city=$city'));
    if (response.statusCode == 200) {
        print(jsonDecode(response.body));
    } else {
        throw Exception('Failed to load weather data');
    }
}

void main() {
    getWeather('Mogadishu');
}

library(httr)
library(jsonlite)

get_weather <- function(city) {
    response <- GET(paste0("https://skyweather.pages.dev/?city=", city))
    content <- content(response, "text")
    fromJSON(content)
}

print(get_weather("Mogadishu"))

import scala.io.Source

object WeatherApp extends App {
    def getWeather(city: String): String = {
        val url = s"https://skyweather.pages.dev/?city=$city"
        Source.fromURL(url).mkString
    }

    println(getWeather("Mogadishu"))
}

import java.net.HttpURLConnection;
import java.net.URL;
import java.util.Scanner;

public class Weather {
    public static void main(String[] args) throws Exception {
        String city = "Mogadishu";
        URL url = new URL("https://skyweather.pages.dev/?city=" + city);
        HttpURLConnection conn = (HttpURLConnection) url.openConnection();
        conn.setRequestMethod("GET");
        
        Scanner sc = new Scanner(url.openStream());
        StringBuilder sb = new StringBuilder();
        while (sc.hasNext()) {
            sb.append(sc.nextLine());
        }
        sc.close();
        
        System.out.println(sb.toString());
    }
}

fetch('https://skyweather.pages.dev/?city=Mogadishu')
    .then(response => response.json())
    .then(data => console.log(data))
    .catch(error => console.error('Error:', error));

using System;
using System.Net.Http;
using System.Threading.Tasks;

class Program
{
    static async Task Main(string[] args)
    {
        string city = "Mogadishu";
        string url = $"https://skyweather.pages.dev/?city={city}";
        
        using (HttpClient client = new HttpClient())
        {
            string response = await client.GetStringAsync(url);
            Console.WriteLine(response);
        }
    }
}

#include 
								
								
								
								
#include 
									
									
									
									
#include 
										
										
										
										

size_t WriteCallback(void* contents, size_t size, size_t nmemb, void* userp)
{
    ((std::string*)userp)->append((char*)contents, size * nmemb);
    return size * nmemb;
}

int main()
{
    std::string city = "Mogadishu";
    std::string url = "https://skyweather.pages.dev/?city=" + city;
    CURL* curl;
    CURLcode res;
    std::string readBuffer;

    curl_global_init(CURL_GLOBAL_DEFAULT);
    curl = curl_easy_init();
    if(curl) {
        curl_easy_setopt(curl, CURLOPT_URL, url.c_str());
        curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteCallback);
        curl_easy_setopt(curl, CURLOPT_WRITEDATA, &readBuffer);
        res = curl_easy_perform(curl);
        if(res != CURLE_OK)
            fprintf(stderr, "curl_easy_perform() failed: %s\n", curl_easy_strerror(res));
        else
            std::cout << readBuffer << std::endl;
        curl_easy_cleanup(curl);
    }
    curl_global_cleanup();
    return 0;
}

curl -s "https://skyweather.pages.dev/?city=Mogadishu" | jq

use LWP::UserAgent;
use JSON;

my $city = 'Mogadishu';
my $url = "https://skyweather.pages.dev/?city=$city";

my $ua = LWP::UserAgent->new;
my $response = $ua->get($url);
my $data = decode_json($response->decoded_content);

print $data;

<?php
$city = 'Mogadishu';
$url = 'https://skyweather.pages.dev/?city=' . urlencode($city);
$response = file_get_contents($url);
$data = json_decode($response, true);

print_r($data);
?>

POSSIBLE RESPONSES FOR THE

The API provides weather information for a given city. When you make a request to the API with a city name, it returns a JSON object with detailed weather data. Here's a breakdown of the different possible responses:

API Request Example:

https://skyweather.pages.dev/?city=Mogadishu

Successful Response (200 OK)

When the API request is successful and the city is found, the response will be in the following format:

{
  "success": true,
  "timestamp": "2024-11-04/23:30:56 UTC+3",
  "developer": {
    "website": "https://apitools.pages.dev"
  },
  "source": "Weather API",
  "data": {
    "city": "string",
    "country": "string",
    "temperature": "string",
    "feels_like": "string",
    "weather": "string",
    "humidity": "string",
    "wind_speed": "string",
    "cloud_coverage": "string"
  },
  "processingTime": "string"
}
}

The response includes the following information:

City: The name of the city.
Country: The name of the country and its flag emoji.
Temperature: The current temperature in degrees Celsius.
Feels Like: The temperature that feels like, factoring in additional weather conditions.
Weather: A description of the current weather condition.
Humidity: The current humidity level as a percentage.
Wind Speed: The current wind speed in meters per second.
Cloud Coverage: The percentage of the sky covered by clouds.

Error Responses (400, 404, 500)

If there is an issue with the request, the API may return the following error messages:

API Request Example:

https://skyweather.pages.dev/

400 Bad Request:

{
  "success": false,
  "timestamp": "2024-11-09/21:50:19 UTC+3",
  "developer": {
    "website": "https://apitools.pages.dev"
  },
  "source": "Weather API",
  "description": "Failed to fetch weather data",
  "data": {
    "error": "City parameter is required to fetch weather data"
  }
}
}

BAD REQUEST (400) This error occurs when the city parameter is missing from the request. Ensure you include the city name in the query string as specified in the API usage documentation.

API Request Example:

https://skyweather.pages.dev/?city=AAAAA

404 City Not Found:

{
  "success": false,
  "timestamp": "2024-11-09/21:50:19 UTC+3",
  "developer": {
    "website": "https://apitools.pages.dev"
  },
  "source": "Weather API",
  "description": "Failed to fetch weather data",
  "data": {
    "error": "City not found"
  }
}
}

BAD REQUEST (404) This error indicates that the city name provided in the request could not be found. Please ensure that the city name is spelled correctly and is a valid city.

API Request Example:

https://skyweather.pages.dev/?city=Mogadishu

500 Internal Server Error:
```
{
  "success": false,
  "timestamp": "2024-11-09/21:50:19 UTC+3",
  "developer": {
    "website": "https://apitools.pages.dev"
  },
  "source": "Weather API",
  "data": {
    "error": "Server Error"
  }
}
}
```
SERVER ERROR (500)This error indicates an issue with the server processing the request. If you encounter this error, please try again later. If the problem persists, contact the API provider.