IBGE SDKs & Libraries: Official and Community Tools (2026)

SDKs overview

The Instituto Brasileiro de Geografia e Estatística (IBGE) primarily serves as the official source for Brazilian statistical, geographic, cartographic, and environmental information. Unlike commercial API providers that often distribute language-specific Software Development Kits (SDKs) to streamline interactions with their services, IBGE's data access model is predominantly based on direct consumption of web services and data downloads. Developers typically interact with IBGE's data through its public APIs, such as the SIDRA API for aggregated statistical data and the IBGE Geocoding API, using standard HTTP requests rather than dedicated SDKs.

This approach means that while there are no traditional, officially maintained SDKs in the sense of a comprehensive library for various programming languages, developers often build their own client libraries or utilize community-contributed packages to simplify interactions. These community efforts abstract the underlying HTTP requests and data parsing, making it easier to integrate IBGE data into applications. The focus remains on direct API calls for data retrieval, which aligns with common practices for RESTful web services, as described by the IETF RFC 7230 series for HTTP/1.1 HTTP Semantics and Content.

The availability of community-driven tools reflects the developer community's need to programmatically access and process the extensive datasets provided by IBGE for purposes such as demographic research, economic analysis, and geospatial applications within Brazil.

Official SDKs by language

IBGE does not provide traditional, officially supported Software Development Kits (SDKs) for specific programming languages in the same manner as commercial API providers like Stripe or Twilio, which offer client libraries for various platforms Stripe API documentation or Twilio SDKs and Helper Libraries. Instead, IBGE exposes its data through web services, primarily RESTful APIs, which are designed to be consumed directly via standard HTTP requests. This means developers typically use generic HTTP client libraries available in their chosen programming language to interact with IBGE's endpoints.

For example, to access the SIDRA API for statistical data or the IBGE Geocoding API, developers would construct HTTP GET requests and parse the JSON or XML responses. This method provides flexibility, allowing integration with virtually any programming environment without being limited to specific language bindings. The table below illustrates this model, indicating that direct API interaction is the primary official method, with community efforts filling the role of language-specific helpers.

Installation

Given that IBGE primarily offers direct API access rather than traditional SDKs, installation typically involves setting up a generic HTTP client library in your preferred programming language. These libraries are standard tools for making web requests and parsing responses, which are essential for interacting with IBGE's various data services.

Python

For Python, the requests library is widely used for making HTTP requests. It simplifies the process of sending requests and handling responses compared to Python's built-in urllib module. To install requests:

pip install requests

JavaScript (Node.js/Browser)

In JavaScript environments, the native fetch API is available in modern browsers and Node.js (since v18, or via a polyfill). For older Node.js versions or more feature-rich clients, axios is a popular choice for making HTTP requests.

To install axios in a Node.js project:

npm install axios

Java

Java 11 and later include the java.net.http.HttpClient for modern, non-blocking HTTP requests. No external installation is required for this. For earlier Java versions, or for more advanced features, libraries like Apache HttpClient or OkHttp are common.

If using Maven for Apache HttpClient:

<dependency>
    <groupId>org.apache.httpcomponents</groupId>
    <artifactId>httpclient</artifactId>
    <version>4.5.13</version>
</dependency>

Ruby

Ruby's standard library includes Net::HTTP for making HTTP requests, so no additional installation is typically required. For a more user-friendly interface, the HTTParty gem is often used.

To install HTTParty:

gem install httparty

PHP

PHP has built-in functions for making HTTP requests (e.g., file_get_contents, curl). For a robust and widely adopted HTTP client, Guzzle is recommended.

To install Guzzle via Composer:

composer require guzzlehttp/guzzle

Quickstart example

This quickstart example demonstrates how to access data from the IBGE SIDRA API using Python and the requests library. The SIDRA API provides access to a vast collection of aggregated statistical data from IBGE.

Objective: Retrieve the population of Brazil for a specific year from the SIDRA API.

API Endpoint for SIDRA: https://servicodados.ibge.gov.br/api/v3/agregados/{aggregate_code}/periodos/{period}/variaveis/{variable_code}/resultados/{level_of_detail}

• aggregate_code: Identifier for the statistical aggregate (e.g., 6579 for 'População residente').
• period: The reference period (e.g., '2022' for the year 2022).
• variable_code: Identifier for the variable (e.g., 93 for 'População').
• level_of_detail: Specifies the geographical level (e.g., '1' for Brazil total).

Python Quickstart

First, ensure you have the requests library installed:

pip install requests

Then, use the following Python code:

import requests
import json

def get_brazil_population(year):
    # SIDRA API endpoint for 'População residente' (aggregate 6579)
    # Variable 'População' (variable 93)
    # Level of detail '1' for Brazil total
    url = f"https://servicodados.ibge.gov.br/api/v3/agregados/6579/periodos/{year}/variaveis/93/resultados/1"

    try:
        response = requests.get(url)
        response.raise_for_status()  # Raise an HTTPError for bad responses (4xx or 5xx)
        data = response.json()

        if data and isinstance(data, list) and len(data) > 0:
            # The structure can be complex, often a list of dictionaries
            # We're looking for the value associated with the 'V' key (valor)
            # and 'D2C' (period description)
            for item in data:
                if 'resultados' in item and isinstance(item['resultados'], list):
                    for result in item['resultados']:
                        if 'series' in result and isinstance(result['series'], dict):
                            for geo_id, series_data in result['series'].items():
                                # geo_id '1' typically refers to Brazil total
                                if geo_id == '1': # Check for Brazil total
                                    for period_data in series_data:
                                        if 'D2C' in period_data and period_data['D2C'] == str(year):
                                            population_value = period_data.get('V')
                                            if population_value and population_value != '...':
                                                print(f"Brazil Population ({year}): {int(population_value):,}")
                                                return int(population_value)
            print(f"Population data for {year} not found or incomplete.")
            return None
        else:
            print(f"No data returned for {year}.")
            return None

    except requests.exceptions.RequestException as e:
        print(f"Error fetching data: {e}")
        return None
    except json.JSONDecodeError:
        print("Error decoding JSON response.")
        return None

# Example usage:
get_brazil_population(2022)
get_brazil_population(2010)
get_brazil_population(2000)

This script defines a function get_brazil_population that takes a year as input, constructs the appropriate SIDRA API URL, sends an HTTP GET request, and then parses the JSON response to extract and print the population figure for Brazil for that year. Error handling is included to manage potential network issues or malformed responses.

Community libraries

While IBGE does not provide official, language-specific SDKs, the developer community has created several libraries to simplify interaction with IBGE's various data services. These community-contributed tools often wrap the direct API calls, providing more idiomatic and user-friendly interfaces for specific programming languages.

Python Libraries

Python has a notable ecosystem of data science and statistical tools, making it a popular choice for interacting with IBGE data. Several community libraries aim to streamline this process:

• sidrapy: This library provides a Pythonic interface to the IBGE SIDRA API. It simplifies the construction of complex queries, handling of parameters, and parsing of the returned JSON data into pandas DataFrames, which are commonly used in data analysis workflows. It abstracts much of the direct HTTP request logic, allowing users to focus on data selection rather than API mechanics.

  pip install sidrapy

  Example usage with sidrapy:

  import sidrapy
  
  table_id = '6579' # Population
  variable_id = '93' # Population variable
  period = '2022'
  geography = 'BR'
  
  df = sidrapy.get_table(
      table_id=table_id,
      variable=variable_id,
      period=period,
      geo='N1',
      geo_level=geography
  )
  
  print(df[['V', 'D2C']].head()) # 'V' is value, 'D2C' is period description
  

• pyibge: Another community effort, pyibge aims to provide a collection of functions to interact with different IBGE web services, including SIDRA and other geographic APIs. It often focuses on ease of use for common data retrieval tasks.

  pip install pyibge

  Example usage with pyibge (note: API usage might vary based on library version):

  from pyibge.sidra import get_data
  
  # Example: Get GDP data for Brazil
  # (Note: Specific table/variable IDs would be needed from IBGE docs)
  # This is a conceptual example as exact pyibge function calls vary.
  # data = get_data(table_id='1846', variable_id='36', period='2022', territorial_level='1')
  # print(data)
  

These community libraries demonstrate the utility of abstracting direct API calls, particularly for complex data structures or frequent access patterns. They enable developers to integrate IBGE data more efficiently into their Python applications, especially within scientific computing and data analysis environments that leverage tools like pandas for data manipulation.

For other languages, community contributions are less formalized or widely adopted as structured libraries. Developers in other ecosystems typically rely on the standard HTTP client libraries, as demonstrated in the Installation section, combined with custom parsing logic tailored to their specific data needs.