Brazil Central Bank Open Data Getting Started Guide (2026)

Getting started overview

The Brazil Central Bank Open Data initiative provides programmatic access to a wide range of economic, financial, and statistical data. This includes time series data, financial statistics, and information related to the Brazilian Open Banking ecosystem. The platform is designed for public access, meaning that most datasets are available without the need for an API key or formal registration process, simplifying initial setup for developers, researchers, and financial analysts. Compliance with Brazil's LGPD (General Data Protection Law) is maintained across the data offerings.

For those new to the platform, the primary method of interaction is through direct HTTP requests to specific API endpoints. While official SDKs are not provided by the Central Bank of Brazil, community-contributed libraries for languages like Python and R exist, which can streamline data retrieval and processing. These unofficial SDKs often encapsulate the HTTP request logic, allowing users to focus on data analysis rather than API integration specifics.

The official documentation, primarily in Portuguese, serves as the authoritative source for endpoint structures and available parameters. Understanding the structure of these endpoints is crucial for effective data retrieval. The API generally follows REST principles, providing data in formats such as JSON or XML, making it compatible with standard web development and data science tooling. For detailed endpoint specifications, refer to the Brazil Central Bank API reference.

Here's a quick reference table outlining the standard steps to get started:

Create an account and get keys

For the primary open data offerings from the Brazil Central Bank, there is generally no requirement to create an account or obtain API keys. The data is freely accessible to the public, aligning with open government data principles. This approach simplifies the onboarding process significantly, as developers can immediately begin making requests to the available endpoints without authentication overhead.

However, it is important to distinguish between general open data and specific services that might require authentication for sensitive operations or personalized access. For instance, while core economic indicators are open, future iterations or specialized services, particularly those related to the broader Open Banking initiative in Brazil, might introduce authentication mechanisms such as OAuth 2.0 or API keys for secure access. Always refer to the official regulations and documentation for the specific service you are integrating to confirm any authentication requirements.

If a particular dataset or service does eventually require authentication, the process would typically involve:

1. Registration: Creating an account on the designated developer portal (if one is established for that specific service).
2. Application Creation: Registering an application to receive client credentials (e.g., client ID and client secret).
3. Key Generation: Generating API keys or configuring OAuth 2.0 flows to obtain access tokens.

As of the current open data landscape, these steps are largely bypassed for public data. Therefore, your focus can remain on identifying the correct API endpoints and understanding their parameters to retrieve the desired information.

Your first request

Making your first request to the Brazil Central Bank Open Data API involves selecting a dataset and constructing a simple HTTP GET request. We will use an endpoint for a common economic indicator: the SELIC rate (Brazil's benchmark interest rate).

The SELIC rate time series can typically be accessed via an endpoint like /dadosabertos/bcdata/selic, though specific paths may vary. For the most up-to-date and accurate endpoint, consult the Brazil Central Bank API documentation.

Let's assume an endpoint for a time series (e.g., for the SELIC rate, identified by a series code like 4390) is structured as follows: https://api.bcb.gov.br/dados/serie/bcdata.sgs.{series_code}/dados?formato=json. We'll use 4390 as an example series code for the SELIC target rate.

Using curl

curl is a command-line tool for making HTTP requests. It's excellent for testing API endpoints quickly.

curl -X GET "https://api.bcb.gov.br/dados/serie/bcdata.sgs.4390/dados?formato=json"

Executing this command will return a JSON array containing objects, each representing a data point with a date and a value for the SELIC rate. The output will resemble:

[
  {
    "data": "01/01/2023",
    "valor": "13.75"
  },
  {
    "data": "01/02/2023",
    "valor": "13.75"
  },
  // ... more data points
]

Using Python

Python's requests library is a popular choice for making HTTP requests programmatically.

import requests
import json

url = "https://api.bcb.gov.br/dados/serie/bcdata.sgs.4390/dados?formato=json"

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

    # Print the first few data points
    for entry in data[:5]:
        print(f"Date: {entry['data']}, Value: {entry['valor']}")

except requests.exceptions.RequestException as e:
    print(f"An error occurred: {e}")

This Python script fetches the data, parses the JSON response, and prints the first five entries, demonstrating how to retrieve and process the information.

Common next steps

Once you've successfully made your first request, consider these common next steps to expand your integration with the Brazil Central Bank Open Data:

1. Explore More Datasets: Dive deeper into the API documentation to discover other available time series, economic indicators, and financial statistics. The Central Bank offers a vast repository, including inflation rates, exchange rates, and banking sector data.
2. Parameterization: Learn how to use query parameters to filter data by date ranges, limit results, or specify output formats. For example, you might want to retrieve data only for the last 12 months or request data in XML instead of JSON.
3. Leverage Unofficial SDKs: While not officially supported, community-developed SDKs for Python and R can simplify data retrieval and integration into data analysis workflows. These libraries often handle common patterns like pagination and data type conversion.
4. Error Handling: Implement robust error handling in your applications. This includes checking HTTP status codes, parsing error messages from the API, and gracefully managing network issues or malformed requests. A good guide for HTTP status codes is available from Mozilla.
5. Data Storage and Caching: For applications that frequently access the same data, consider implementing a caching strategy to reduce API calls and improve performance. Store retrieved data in a local database or cache for faster access.
6. Visualization and Analysis: Integrate the retrieved data into visualization tools (e.g., Matplotlib, Seaborn, Tableau) or analytical platforms to derive insights. This is often the ultimate goal of accessing economic data.
7. Stay Updated: The Central Bank of Brazil may update its API endpoints or introduce new datasets. Regularly check the official documentation for announcements or changes to ensure your integration remains functional and up-to-date.

Troubleshooting the first call

When encountering issues with your initial API calls to the Brazil Central Bank Open Data, several common problems and solutions can help diagnose the issue:

1. Incorrect Endpoint URL:
   • Symptom: HTTP 404 Not Found or unexpected data.
   • Solution: Double-check the URL against the official API documentation. API paths can be case-sensitive, and slight variations can lead to errors. Ensure the series code or dataset identifier is correct.
2. Network Issues:
   • Symptom: Connection timed out, host unreachable.
   • Solution: Verify your internet connection. If you are in a corporate network, check if a proxy is required or if firewalls are blocking outbound requests to the API domain. Test with a simple request to a known working URL (e.g., curl https://google.com).
3. Missing or Incorrect Parameters:
   • Symptom: HTTP 400 Bad Request or an empty response.
   • Solution: Review the API documentation for required parameters (e.g., formato=json). Ensure all parameters are correctly formatted and included in the query string. Some endpoints might require specific date formats or other filters.
4. JSON Parsing Errors:
   • Symptom: Your code fails to parse the response, indicating invalid JSON.
   • Solution: The API might return non-JSON content on error (e.g., an HTML error page). Inspect the raw response body to confirm it's valid JSON before attempting to parse it. Use a JSON validator tool if needed.
5. Rate Limiting:
   • Symptom: HTTP 429 Too Many Requests.
   • Solution: While the Brazil Central Bank Open Data is generally permissive, excessive requests in a short period might trigger rate limits. Implement delays between requests or batch your data retrieval. Check the API documentation for any stated rate limits.
6. Understanding Response Structure:
   • Symptom: Data is returned, but your application isn't correctly extracting values.
   • Solution: Print the full raw JSON or XML response to understand its exact structure. Field names might differ from expectations (e.g., data vs. date, valor vs. value).
7. Language Barrier (Portuguese Documentation):
   • Symptom: Difficulty understanding documentation or error messages.
   • Solution: Use online translation tools to interpret the official Portuguese documentation. Community forums or unofficial SDKs might also offer explanations in English.