search
HomeBackend DevelopmentC++Consuming APIs in C: a practical guide for modern developers

Consuming APIs in C: a practical guide for modern developers

Today, consuming web APIs is a common practice for exchanging data between applications. Tutorials on consuming APIs in languages like JavaScript, Python, or PHP are plentiful, but C—often associated with system-level programming—is rarely considered for this purpose. However, C is perfectly capable of handling API requests, making it a viable choice for scenarios like Point of Sale (PoS) systems, IoT devices, or embedded applications, where C is already used for its efficiency and low-level control.

This article explores how to consume APIs in C, leveraging the libcurl library. By the end, you'll understand how to fetch and process data from APIs using C, and why this approach is relevant even in modern development.

Why use C for consuming APIs?

While higher-level languages dominate web development, C is still a practical choice for consuming APIs in specific use cases:

  • Performance: C provides high performance and minimal overhead, making it suitable for resource-constrained environments like IoT devices.
  • Control: direct memory management allows fine-tuned optimization, especially for embedded systems.
  • Interoperability: C’s widespread use means it integrates well with system-level operations, such as controlling hardware, sensors, or other peripherals.
  • Longevity: applications built in C often have long lifespans, especially in industries like retail or manufacturing.

Introducing libcurl: the tool for HTTP in C

To consume APIs in C, libcurl is the go-to library. It’s an open-source, portable, and feature-rich library for handling network requests over HTTP, HTTPS, FTP, and more. It supports:

  • Making GET, POST, and other HTTP requests.
  • Handling headers and authentication.
  • Processing responses efficiently.

Basic steps for consuming an API in C

Let’s walk through the process of consuming an API using C, focusing on a real-world example of fetching JSON data.

Setup and installation

To use libcurl, you need to install it on your system. For most Linux distributions, this can be done with:

sudo apt-get install libcurl4-openssl-dev

On Windows, you can download precompiled binaries from the libcurl website: https://curl.se/download.html

On macOS if you use Homebrew you can install it via

brew install curl

Structuring your C program

A simple C program to fetch data from an API involves the following components:

  • Initializing libcurl.
  • Configuring the API request (URL, HTTP method, headers, etc.).
  • Receiving and storing the response.
  • Cleaning up resources.

Here’s an example program to fetch JSON data from a public API:

sudo apt-get install libcurl4-openssl-dev

Steps to run

Save the code in a file, e.g., get.c.
Compile it with the following command:

brew install curl

Run the compiled program:

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

// Struct to hold response data
struct Memory {
    char *response;
    size_t size;
};

// Callback function to handle the data received from the API
static size_t ResponseCallback(void *contents, size_t size, size_t nmemb, void *userp) {
    size_t totalSize = size * nmemb;
    struct Memory *mem = (struct Memory *)userp;

    printf(". %zu %zu\n", size, nmemb);
    char *ptr = realloc(mem->response, mem->size + totalSize + 1);
    if (ptr == NULL) {
        printf("Not enough memory to allocate buffer.\n");
        return 0;
    }

    mem->response = ptr;
    memcpy(&(mem->response[mem->size]), contents, totalSize);
    mem->size += totalSize;
    mem->response[mem->size] = '<pre class="brush:php;toolbar:false">gcc get.c -o get -lcurl
'; return totalSize; } int main() { CURL *curl; CURLcode res; struct Memory chunk; chunk.response = malloc(1); // Initialize memory chunk.size = 0; // No data yet curl_global_init(CURL_GLOBAL_DEFAULT); curl = curl_easy_init(); if (curl) { // Set URL of the API endpoint char access_token[] = "your-access-token"; char slug[] = "home"; char version[]= "draft"; char url[256]; snprintf(url, sizeof(url), "https://api.storyblok.com/v2/cdn/stories/%s?version=%s&token=%s", slug, version, access_token); // Print the URL printf("URL: %s\n", url); // initializing libcurl // setting the URL curl_easy_setopt(curl, CURLOPT_URL, url ); // Follow redirect curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1L); // Set callback function to handle response data curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, ResponseCallback); // Pass the Memory struct to the callback function curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void *)&chunk); // Perform the HTTP GET request res = curl_easy_perform(curl); // Check for errors if (res != CURLE_OK) { fprintf(stderr, "curl_easy_perform() failed: %s\n", curl_easy_strerror(res)); } else { printf("Response data size: %zu\n", chunk.size); //printf("Response data: \n%s\n", chunk.response); } // Cleanup curl_easy_cleanup(curl); } // Free allocated memory free(chunk.response); curl_global_cleanup(); return 0; }

Understanding the callback mechanism in HTTP responses with libcurl

When working with libcurl to handle HTTP responses in C, it’s important to understand the behavior of the callback function. The callback function you define to process the response data, such as the ResponseCallback function, may be invoked multiple times for a single HTTP response. Here’s why and how this works.

Why is the callback invoked multiple times?

The callback mechanism in libcurl is designed to handle data efficiently and flexibly. Instead of waiting for the entire response to be downloaded before processing it, libcurl processes the response in smaller chunks, calling your callback function as each chunk is received.

This behavior allows:

  • Efficient Memory Usage: by processing chunks incrementally, you avoid the need to allocate a large block of memory upfront for the entire response.
  • Streamed Processing: you can process or act on each chunk as it arrives, which is useful for streaming large responses or handling data in real-time.

How Does It Work?
Each time a chunk of data is received from the server, libcurl calls your callback function. The size of each chunk depends on network conditions, buffer sizes, and libcurl’s internal logic.
The callback has to accumulate the chunks, ultimately reconstructing the full response.

Here’s an example sequence:

  1. The server starts sending the response.
  2. libcurl receives the first chunk and calls the callback.
  3. The callback processes or stores the chunk.
  4. libcurl receives the next chunk and calls the callback again.
  5. This process continues until the entire response is received.

Step-by-Step source code explanation for ResponseCallback function

The ResponseCallback is the function called when data is received by libcurl.

Function Declaration

sudo apt-get install libcurl4-openssl-dev
  • void *contents: this is a pointer to the data received from the server. libcurl provides this buffer and fills it with the data it downloads.
  • size_t size and size_t nmemb: These represent the size of each memory block (size) and the number of blocks (nmemb). Together, size * nmemb gives the total size of the data received in this chunk.
  • void *userp: this is a user-defined pointer passed to the callback function via curl_easy_setopt(curl, CURLOPT_WRITEDATA, ...). In this example, it's a pointer to a struct Memory object, which stores the full response.

Calculate total data size

brew install curl

This computes the total size of the current chunk of data received by multiplying the size of one block (size) with the number of blocks (nmemb).
For example, if the server sends 8 blocks of 256 bytes each, totalSize will be 8 * 256 = 2048 bytes.

Access user data (struct Memory)

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

// Struct to hold response data
struct Memory {
    char *response;
    size_t size;
};

// Callback function to handle the data received from the API
static size_t ResponseCallback(void *contents, size_t size, size_t nmemb, void *userp) {
    size_t totalSize = size * nmemb;
    struct Memory *mem = (struct Memory *)userp;

    printf(". %zu %zu\n", size, nmemb);
    char *ptr = realloc(mem->response, mem->size + totalSize + 1);
    if (ptr == NULL) {
        printf("Not enough memory to allocate buffer.\n");
        return 0;
    }

    mem->response = ptr;
    memcpy(&(mem->response[mem->size]), contents, totalSize);
    mem->size += totalSize;
    mem->response[mem->size] = '<pre class="brush:php;toolbar:false">gcc get.c -o get -lcurl
'; return totalSize; } int main() { CURL *curl; CURLcode res; struct Memory chunk; chunk.response = malloc(1); // Initialize memory chunk.size = 0; // No data yet curl_global_init(CURL_GLOBAL_DEFAULT); curl = curl_easy_init(); if (curl) { // Set URL of the API endpoint char access_token[] = "your-access-token"; char slug[] = "home"; char version[]= "draft"; char url[256]; snprintf(url, sizeof(url), "https://api.storyblok.com/v2/cdn/stories/%s?version=%s&token=%s", slug, version, access_token); // Print the URL printf("URL: %s\n", url); // initializing libcurl // setting the URL curl_easy_setopt(curl, CURLOPT_URL, url ); // Follow redirect curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1L); // Set callback function to handle response data curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, ResponseCallback); // Pass the Memory struct to the callback function curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void *)&chunk); // Perform the HTTP GET request res = curl_easy_perform(curl); // Check for errors if (res != CURLE_OK) { fprintf(stderr, "curl_easy_perform() failed: %s\n", curl_easy_strerror(res)); } else { printf("Response data size: %zu\n", chunk.size); //printf("Response data: \n%s\n", chunk.response); } // Cleanup curl_easy_cleanup(curl); } // Free allocated memory free(chunk.response); curl_global_cleanup(); return 0; }

The userp pointer is cast to a struct Memory *. This struct was passed earlier in the main program and is used to accumulate the received data.

The struct Memory is defined as:

./get
  • response: a dynamically allocated string that stores the downloaded data.
  • size: the current size of the response string.

Reallocate memory

static size_t ResponseCallback(void *contents, size_t size, size_t nmemb, void *userp)

Resizes the response buffer to accommodate the new data chunk:

  • mem->size: the current size of the buffer.
  • totalSize: The size of the new chunk.
  • 1: Space for the null-terminator (

The above is the detailed content of Consuming APIs in C: a practical guide for modern developers. For more information, please follow other related articles on the PHP Chinese website!

Statement
The content of this article is voluntarily contributed by netizens, and the copyright belongs to the original author. This site does not assume corresponding legal responsibility. If you find any content suspected of plagiarism or infringement, please contact admin@php.cn
Using XML in C  : A Guide to Libraries and ToolsUsing XML in C : A Guide to Libraries and ToolsMay 09, 2025 am 12:16 AM

XML is used in C because it provides a convenient way to structure data, especially in configuration files, data storage and network communications. 1) Select the appropriate library, such as TinyXML, pugixml, RapidXML, and decide according to project needs. 2) Understand two ways of XML parsing and generation: DOM is suitable for frequent access and modification, and SAX is suitable for large files or streaming data. 3) When optimizing performance, TinyXML is suitable for small files, pugixml performs well in memory and speed, and RapidXML is excellent in processing large files.

C# and C  : Exploring the Different ParadigmsC# and C : Exploring the Different ParadigmsMay 08, 2025 am 12:06 AM

The main differences between C# and C are memory management, polymorphism implementation and performance optimization. 1) C# uses a garbage collector to automatically manage memory, while C needs to be managed manually. 2) C# realizes polymorphism through interfaces and virtual methods, and C uses virtual functions and pure virtual functions. 3) The performance optimization of C# depends on structure and parallel programming, while C is implemented through inline functions and multithreading.

C   XML Parsing: Techniques and Best PracticesC XML Parsing: Techniques and Best PracticesMay 07, 2025 am 12:06 AM

The DOM and SAX methods can be used to parse XML data in C. 1) DOM parsing loads XML into memory, suitable for small files, but may take up a lot of memory. 2) SAX parsing is event-driven and is suitable for large files, but cannot be accessed randomly. Choosing the right method and optimizing the code can improve efficiency.

C   in Specific Domains: Exploring Its StrongholdsC in Specific Domains: Exploring Its StrongholdsMay 06, 2025 am 12:08 AM

C is widely used in the fields of game development, embedded systems, financial transactions and scientific computing, due to its high performance and flexibility. 1) In game development, C is used for efficient graphics rendering and real-time computing. 2) In embedded systems, C's memory management and hardware control capabilities make it the first choice. 3) In the field of financial transactions, C's high performance meets the needs of real-time computing. 4) In scientific computing, C's efficient algorithm implementation and data processing capabilities are fully reflected.

Debunking the Myths: Is C   Really a Dead Language?Debunking the Myths: Is C Really a Dead Language?May 05, 2025 am 12:11 AM

C is not dead, but has flourished in many key areas: 1) game development, 2) system programming, 3) high-performance computing, 4) browsers and network applications, C is still the mainstream choice, showing its strong vitality and application scenarios.

C# vs. C  : A Comparative Analysis of Programming LanguagesC# vs. C : A Comparative Analysis of Programming LanguagesMay 04, 2025 am 12:03 AM

The main differences between C# and C are syntax, memory management and performance: 1) C# syntax is modern, supports lambda and LINQ, and C retains C features and supports templates. 2) C# automatically manages memory, C needs to be managed manually. 3) C performance is better than C#, but C# performance is also being optimized.

Building XML Applications with C  : Practical ExamplesBuilding XML Applications with C : Practical ExamplesMay 03, 2025 am 12:16 AM

You can use the TinyXML, Pugixml, or libxml2 libraries to process XML data in C. 1) Parse XML files: Use DOM or SAX methods, DOM is suitable for small files, and SAX is suitable for large files. 2) Generate XML file: convert the data structure into XML format and write to the file. Through these steps, XML data can be effectively managed and manipulated.

XML in C  : Handling Complex Data StructuresXML in C : Handling Complex Data StructuresMay 02, 2025 am 12:04 AM

Working with XML data structures in C can use the TinyXML or pugixml library. 1) Use the pugixml library to parse and generate XML files. 2) Handle complex nested XML elements, such as book information. 3) Optimize XML processing code, and it is recommended to use efficient libraries and streaming parsing. Through these steps, XML data can be processed efficiently.

See all articles

Hot AI Tools

Undresser.AI Undress

Undresser.AI Undress

AI-powered app for creating realistic nude photos

AI Clothes Remover

AI Clothes Remover

Online AI tool for removing clothes from photos.

Undress AI Tool

Undress AI Tool

Undress images for free

Clothoff.io

Clothoff.io

AI clothes remover

Video Face Swap

Video Face Swap

Swap faces in any video effortlessly with our completely free AI face swap tool!

Hot Tools

WebStorm Mac version

WebStorm Mac version

Useful JavaScript development tools

SublimeText3 English version

SublimeText3 English version

Recommended: Win version, supports code prompts!

Dreamweaver CS6

Dreamweaver CS6

Visual web development tools

DVWA

DVWA

Damn Vulnerable Web App (DVWA) is a PHP/MySQL web application that is very vulnerable. Its main goals are to be an aid for security professionals to test their skills and tools in a legal environment, to help web developers better understand the process of securing web applications, and to help teachers/students teach/learn in a classroom environment Web application security. The goal of DVWA is to practice some of the most common web vulnerabilities through a simple and straightforward interface, with varying degrees of difficulty. Please note that this software

SublimeText3 Chinese version

SublimeText3 Chinese version

Chinese version, very easy to use