C Weather API: Code, Examples & Forecasts

Oct 29, 2025 by Jhon Lennon 42 views

Hey there, code enthusiasts! Ever wanted to whip up your own weather app or integrate weather data into your projects using C? Well, you're in the right place! Today, we're diving headfirst into the world of Weather Forecast APIs and how you can get started with a C example. We'll cover everything from grabbing the API key to parsing the JSON data and displaying the weather information. So, buckle up, grab your favorite coding beverage, and let's get started. Weather APIs are your go-to source for getting real-time weather information, forecasts, and more. They provide a structured way to access weather data, making it easy to integrate into your applications. Using C, a powerful and versatile language, you can interact with these APIs to retrieve and process weather data. Think of it like this: the API is the waiter, and you're ordering the weather. You send your request (your order), and the waiter (API) brings back the data (your weather information).

Let's get down to the nitty-gritty. Before you start coding, you'll need a Weather API key. There are tons of weather APIs out there, both free and paid. Some popular choices include OpenWeatherMap, WeatherAPI.com, and AccuWeather. Each API has its own set of features, data availability, and pricing. I recommend starting with a free tier to test the waters before committing to a paid plan. Once you've chosen your API and signed up for an account, you'll receive an API key. This key is your unique identifier and is required for accessing the API data. Treat it like a password and keep it safe! You'll include this key in your API requests to authenticate your access. This tells the API that you are authorized to use its services. The best part? These APIs provide a wealth of information, from the current temperature and conditions to detailed forecasts, humidity levels, and even wind speeds. This data can be used to create detailed weather reports or make decisions based on the weather conditions. Let's explore how to use a Weather API in C. The first step involves making HTTP requests to the API endpoints. You'll typically use the curl library or similar tools to send requests and retrieve data. The API returns the data in a structured format, usually JSON (JavaScript Object Notation). This format is easy to parse and extract the relevant weather information. You'll need to parse the JSON data to extract the weather information, such as the temperature, conditions, and other details. Then, you can use the extracted data to display the weather information in your application. So let's write some code to see how it works!

Getting Started: Setting Up Your C Environment

Alright, folks, before we dive into the code, let's get our environment set up. You'll need a C compiler and a text editor. If you're on Linux or macOS, you likely already have a C compiler (like GCC) installed. If you're on Windows, you can download a compiler like MinGW or use an IDE like Code::Blocks or Visual Studio, which come with their own compilers. Once you have a C compiler set up, it's time to create a new project. You can do this using your IDE or by creating a new directory and a .c file in it. For our example, we'll name our file weather_app.c. Now, let's include the necessary headers. These headers provide the functions and definitions we'll need for our weather application. We'll start with the standard input/output header: #include <stdio.h>. This header provides functions for input and output operations, such as printing to the console. Next, we'll include the header for string manipulation: #include <string.h>. This header provides functions for working with strings, which we'll need for handling API responses. Now, let's include the headers for network requests. For making HTTP requests, we will use the libcurl library. So, we'll include: #include <curl/curl.h>. The curl.h header contains the necessary definitions and functions for using libcurl. We need to install libcurl separately using the system package manager on Linux. On Debian/Ubuntu, you can install it using sudo apt-get install libcurl4-gnutls-dev. On macOS, you can use brew install curl. On Windows, you can download the appropriate package from the libcurl website. This is how to get the tools installed so that we can write some code. Let's get to it!

Once you have the basics set up, you can start incorporating the weather API. With your compiler and editor ready, you are prepared to write the C code. In the following sections, we will delve into practical code examples and show you how to pull weather data from an API, handle it, and put it on display. Let's get to it!

Installing the required libraries

Before you can start coding, you'll need to install the libcurl library. This library is crucial for making HTTP requests to the Weather API. Here's how to install it on different operating systems:

Linux (Debian/Ubuntu): Open your terminal and run the following command: sudo apt-get update && sudo apt-get install libcurl4-openssl-dev.
macOS (using Homebrew): If you don't have Homebrew, install it first. Then, run: brew install curl.
Windows: Download the libcurl library from the official website. You'll need to extract the files and configure your compiler to link to the library. This process can vary depending on your compiler (e.g., MinGW, Visual Studio).

After the installation, make sure the library and include paths are correctly configured in your project settings. This will allow the compiler to find the necessary header files and link the library during compilation. This process is different on different operating systems. For example, for Windows, you have to add the paths in your compiler and linker settings. Once the installation is complete, you should be able to include the necessary headers in your C code and start using the libcurl functions. After setting up the environment, you are ready to start writing code that requests and displays weather data. Let's move on and write some code!

Making HTTP Requests with `libcurl` in C

Alright, folks, it's time to get our hands dirty with some code! Let's start with the heart of our application: making HTTP requests to the Weather API. We'll be using libcurl for this. First things first, we need to include the curl.h header in our code to access the necessary functions. Remember, we already included this in the setup section. Next, we'll create a function to make the HTTP GET request. This function will take the API endpoint URL as input and return the response data. Inside the function, we'll initialize a CURL handle using curl_easy_init(). This handle is used to manage the transfer. After initializing the handle, we need to set various options. These options tell libcurl how to perform the request. We will set the URL using curl_easy_setopt() and specify the URL we want to fetch. We'll also set a callback function using curl_easy_setopt() with the CURLOPT_WRITEFUNCTION option. This callback function will handle the received data. We'll also need to provide a pointer to a buffer where the data should be written. After setting up the options, we'll execute the request using curl_easy_perform(). This function initiates the transfer and waits for it to complete. If the request is successful, it returns CURLE_OK. Otherwise, it returns an error code. Finally, we'll clean up by using curl_easy_cleanup() to release the resources. Also, you have to always check for errors at each step to catch any potential problems. Now, let's define the callback function that will handle the received data. This function will be called by libcurl whenever data is received from the API. The function should have the following signature: size_t write_callback(void *contents, size_t size, size_t nmemb, void *userp). This callback function receives the data, its size, the number of members, and a pointer to user data. Inside the callback function, we'll append the received data to our buffer. Also, remember to handle potential memory allocation issues. We'll need to resize the buffer to accommodate the new data. Always, always free the memory that you allocate. Always check for errors. After the request is complete, we'll parse the JSON response. This involves extracting the relevant weather information from the JSON data. This is how you set up the HTTP request and handle the responses from your server. We have the data, let's parse it.

Code Example: Making a GET Request

#include <stdio.h>
#include <string.h>
#include <curl/curl.h>

// Callback function to write the response data
size_t write_callback(void *contents, size_t size, size_t nmemb, void *userp) {
    size_t realsize = size * nmemb;
    struct MemoryStruct *mem = (struct MemoryStruct *)userp;

    char *ptr = realloc(mem->memory, mem->size + realsize + 1);
    if (ptr == NULL) {
        /* out of memory! */
        fprintf(stderr, "not enough memory (realloc returned NULL)\n");
        return 0;
    }

    mem->memory = ptr;
    memcpy(&(mem->memory[mem->size]), contents, realsize);
    mem->size += realsize;
    mem->memory[mem->size] = 0;

    return realsize;
}

// Structure to hold the response data
struct MemoryStruct {
    char *memory;
    size_t size;
};

// Function to make the HTTP GET request
char *get_request(const char *url) {
    CURL *curl;
    CURLcode res;
    struct MemoryStruct chunk;

    chunk.memory = malloc(1);
    chunk.size = 0;

    curl = curl_easy_init();
    if (curl) {
        curl_easy_setopt(curl, CURLOPT_URL, url);
        curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_callback);
        curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void *)&chunk);
        res = curl_easy_perform(curl);
        if (res != CURLE_OK) {
            fprintf(stderr, "curl_easy_perform() failed: %s\n",
                    curl_easy_strerror(res));
        }

        curl_easy_cleanup(curl);
    }

    return chunk.memory;
}

int main(void) {
    const char *api_url = "https://api.weatherapi.com/v1/current.json?key=YOUR_API_KEY&q=London";
    char *response = get_request(api_url);

    if (response) {
        printf("Response:\n%s\n", response);
        free(response);
    } else {
        fprintf(stderr, "Failed to get weather data\n");
    }

    return 0;
}

In this example, the get_request function makes an HTTP GET request to the specified URL using libcurl. The write_callback function is responsible for handling the response data, and the main function calls get_request and prints the response. Remember to replace `