INEI SDKs & Libraries: Accessing Peruvian Statistical Data (2026)

SDKs overview

The Instituto Nacional de Estadística e Informática (INEI) offers a REST API for programmatic access to its various statistical datasets, which include census data, economic indicators, and social statistics specific to Peru. While INEI maintains comprehensive official documentation for its API, the provision of official Software Development Kits (SDKs) is not a primary focus. Instead, developers typically interact with the INEI API directly using standard HTTP client libraries available in most programming languages. This approach allows for broad compatibility and flexibility in how the data is consumed.

SDKs and libraries typically encapsulate the complexities of API interaction, handling authentication, request formatting, and response parsing. For INEI's API, developers often build custom wrappers or utilize existing community-contributed libraries to streamline these processes. This page outlines the common methods for interacting with the INEI API, focusing on direct API consumption patterns and highlighting notable community efforts where available. The emphasis is on enabling developers to efficiently integrate INEI's rich statistical resources into their applications, research, and analytical workflows.

Understanding how to interact with RESTful APIs is fundamental for leveraging the INEI data. A basic understanding of HTTP methods (GET, POST), request headers, and JSON response structures is beneficial. Developers can use various tools and libraries to make these requests, from command-line utilities like curl to language-specific HTTP client libraries.

Official SDKs by language

As of the latest review, INEI does not publish official, language-specific SDKs in the traditional sense, where a dedicated software package is provided for each programming language. The INEI API is designed as a standard RESTful web service, meaning it communicates over HTTP using standard methods and typically returns data in JSON format. This design allows developers to use any programming language with an HTTP client to interact with the API directly.

This approach offers maximum flexibility but places the onus on developers to construct their API requests and parse the JSON responses. While there are no official SDKs, the INEI provides detailed API documentation in Spanish that specifies endpoints, parameters, and response formats, which serves as the primary resource for developers. This documentation is essential for understanding how to formulate requests correctly and interpret the data returned by the API.

The absence of official SDKs means that developers often rely on general-purpose HTTP client libraries available in their chosen programming language. For example, Python developers might use requests, JavaScript developers might use fetch or axios, and Java developers might use HttpClient. These libraries provide the foundational capabilities needed to interact with the INEI API effectively.

Common Libraries for API Interaction

Given the RESTful nature of the INEI API, developers commonly use the following types of libraries for interaction:

• HTTP Client Libraries: These libraries handle the low-level details of making HTTP requests, including setting headers, managing connections, and processing responses.
• JSON Parsing Libraries: After receiving a response, these libraries help convert the JSON string into native data structures (e.g., Python dictionaries, JavaScript objects) for easier manipulation.

Here's a table illustrating the common approach:

Installation

Since INEI does not distribute official, dedicated SDKs, installation typically involves setting up the chosen programming language environment and installing general-purpose HTTP client libraries. The process is standard for each respective language and its package manager.

Python Example (using pip)

To install the popular requests library for Python, you would use pip, the Python package installer:

pip install requests

This command downloads and installs the requests package and its dependencies, making it available for use in your Python scripts. Python is a popular choice for data processing and analysis, making libraries like requests particularly useful for interacting with statistical APIs like INEI's.

JavaScript Example (using npm or yarn)

For JavaScript projects (e.g., Node.js environments or front-end applications), you might use axios or rely on the native fetch API. To install axios:

npm install axios
# or
yarn add axios

If you prefer to use the built-in fetch API in modern browsers or Node.js (version 18+), no installation is required, as it's globally available.

R Example (using install.packages)

R is commonly used in statistical analysis. To install the httr and jsonlite packages:

install.packages("httr")
install.packages("jsonlite")

These commands will download and install the specified packages from CRAN, making them ready for use in your R scripts for making HTTP requests and handling JSON data.

Quickstart example

This quickstart example demonstrates how to fetch data from the INEI API using Python's requests library. The example targets a hypothetical endpoint for population data (developers should refer to the INEI API documentation for actual endpoint details and available datasets).

Python Quickstart

First, ensure you have the requests library installed (see Installation section).

import requests
import json

# Base URL for the INEI API (this is an illustrative example)
# Please consult the official INEI API documentation for actual endpoints
BASE_URL = "https://www.inei.gob.pe/servicios/api/v1/" # Placeholder URL

# Example endpoint for fetching a dataset (e.g., population by region)
# Replace with an actual endpoint from INEI's documentation
ENDPOINT = "poblacion/data/region/lima"

# Construct the full URL
url = f"{BASE_URL}{ENDPOINT}"

print(f"Fetching data from: {url}")

try:
    # Make a GET request to the INEI API
    response = requests.get(url)

    # Raise an HTTPError for bad responses (4xx or 5xx)
    response.raise_for_status()

    # Parse the JSON response
    data = response.json()

    print("Successfully fetched data.")
    # Print the first few items or a summary of the data
    if isinstance(data, list) and len(data) > 0:
        print(f"Number of records: {len(data)}")
        print("First record example:")
        print(json.dumps(data[0], indent=2))
    elif isinstance(data, dict):
        print("Data is a dictionary:")
        print(json.dumps(data, indent=2))
    else:
        print("Unexpected data format.")

except requests.exceptions.HTTPError as http_err:
    print(f"HTTP error occurred: {http_err} - {response.status_code} - {response.text}")
except requests.exceptions.ConnectionError as conn_err:
    print(f"Connection error occurred: {conn_err}")
except requests.exceptions.Timeout as timeout_err:
    print(f"Timeout error occurred: {timeout_err}")
except requests.exceptions.RequestException as req_err:
    print(f"An unexpected error occurred: {req_err}")
except json.JSONDecodeError as json_err:
    print(f"JSON decoding error: {json_err} - Response text: {response.text}")

This script demonstrates the basic steps:

1. Import necessary libraries (requests for HTTP, json for pretty printing).
2. Define the base URL and a specific endpoint.
3. Make a GET request to the constructed URL.
4. Check for HTTP errors.
5. Parse the JSON response into a Python dictionary or list.
6. Print a portion of the retrieved data.

Remember to replace the BASE_URL and ENDPOINT with actual valid values obtained from the official INEI API documentation to ensure the code functions correctly.

Community libraries

Given the absence of official SDKs from INEI, the developer community often creates and maintains libraries to simplify interaction with public APIs. These community-driven efforts can provide higher-level abstractions over raw HTTP requests, making it easier for developers to fetch, filter, and process INEI data.

While specific, widely-adopted community SDKs for the INEI API are not extensively documented in public repositories as of this writing, developers frequently share utility functions or wrapper scripts in academic contexts, data science forums, or personal GitHub repositories. These tools often serve to:

• Simplify API calls: Abstracting the URL construction and parameter handling.
• Automate pagination: Handling responses that are split across multiple pages.
• Facilitate data cleaning: Pre-processing raw JSON responses into more usable formats (e.g., Pandas DataFrames in Python, data frames in R).
• Provide language-specific convenience methods: Offering functions that align with common data manipulation patterns in a given language.

Developers interested in community contributions should search platforms like GitHub, PyPI (for Python), or CRAN (for R) using terms such as "INEI API", "Perú estadísticas", or "INEI data" combined with their preferred programming language. Projects listed might be in varying states of maintenance and maturity, so evaluating their activity, documentation, and community support is advisable.

It's important to verify the reliability and security of any third-party library before integrating it into production systems. Developers should particularly check the source code, review issues, and assess the frequency of updates. For critical applications, building custom wrappers directly on top of robust HTTP client libraries often provides greater control and security, aligning with best practices for API client library development.

As the INEI API continues to evolve, community interest and contributions may grow, potentially leading to more formalized and widely adopted libraries. Staying engaged with data science communities focused on Latin American statistics or Peruvian data can be a good way to discover emerging tools and shared practices for interacting with INEI's valuable datasets.