APIs financeiras em Python: como usar

Por que Python virou a linguagem padrão do mercado financeiro

Se você acompanha o mundo do trading e investimentos há algum tempo, já deve ter percebido que Python aparece em todo lugar. Nas mesas das gestoras, nos modelos de risco dos bancos, nos algoritmos dos fundos quant e, cada vez mais, no setup dos traders independentes que querem ir além das planilhas do Excel.

Não é coincidência. Python se tornou a linguagem padrão do mercado financeiro por razões muito concretas: sintaxe simples, biblioteca absurdamente rica de pacotes financeiros e uma comunidade enorme que resolve problemas em tempo real. Enquanto linguagens como R e MATLAB ainda têm seu espaço, Python democratizou o acesso a ferramentas que antes eram privilégio de equipes com orçamento de milhões.

A keyword aqui é democratização. Com algumas linhas de código, você consegue baixar 10 anos de cotações de qualquer ação brasileira, calcular médias móveis, RSI, MACD e simular uma estratégia completa. Coisas que uma corretora grande pagaria uma equipe de quants pra fazer, você faz no seu computador, de graça, numa tarde.

Neste guia, vamos explorar as principais APIs financeiras para Python disponíveis no mercado brasileiro, como usar na prática e como começar a automatizar sua análise de mercado do zero.

As principais APIs gratuitas para dados financeiros brasileiros

Antes de sair instalando coisa, é importante entender o que cada ferramenta faz e qual resolve seu problema específico. O ecossistema de dados financeiros em Python tem camadas: você precisa de dados históricos, dados em tempo real, indicadores macroeconômicos e, dependendo do seu objetivo, dados de renda fixa também.

yfinance: o ponto de partida pra maioria

O yfinance é provavelmente o pacote mais usado por traders e analistas que estão começando com Python. Ele acessa os dados do Yahoo Finance de forma gratuita e sem precisar de cadastro ou chave de API.

Pra instalar, é só rodar:

pip install yfinance

E pra baixar cotações históricas de uma ação brasileira:

import yfinance as yf

# Ações brasileiras usam o sufixo .SA
petro = yf.Ticker("PETR4.SA")

# Baixar dados históricos
histórico = petro.history(period="1y")
print(histórico.head())

O retorno é um DataFrame do pandas com colunas de Open, High, Low, Close, Volume e Dividends. Limpo, pronto pra usar.

Você pode buscar múltiplos ativos de uma vez:

tickers = ["PETR4.SA", "VALE3.SA", "ITUB4.SA", "BBDC4.SA"]
dados = yf.download(tickers, start="2023-01-01", end="2024-12-31")

O yfinance também traz dados fundamentalistas básicos, dividendos, splits e até informações sobre opções. Não é perfeito e às vezes tem inconsistências nos dados históricos, mas pra começar e prototipar estratégias é excelente.

BCB (Banco Central do Brasil): dados macroeconômicos oficiais

O Banco Central disponibiliza uma API REST gratuita com séries temporais de indicadores macroeconômicos: Selic, IPCA, câmbio, M2, IGP-M e centenas de outras séries. É a fonte oficial, então a qualidade dos dados é alta.

Você pode acessar via requests direto ou usar o pacote python-bcb:

pip install python-bcb

from bcb import sgs

# Série 11 = taxa Selic diária
selic = sgs.get({'Selic': 11}, start='2020-01-01')
print(selic.tail(10))

Pra quem quer entender como a Selic afeta diferentes classes de ativos, ter esses dados históricos direto no Python é valioso. Você cruza com cotações de ações, fundos imobiliários ou renda fixa e analisa correlações reais, com dados reais.

investpy e alternativas pra Investing.com

O investpy foi por muito tempo a biblioteca padrão pra acessar dados do Investing.com via Python, mas passou por instabilidades após mudanças no site. Se você quiser tentar:

pip install investpy

Uma alternativa mais robusta atualmente é usar a API oficial do Alpha Vantage (tem plano gratuito com limite de requisições) ou o Quandl/Nasdaq Data Link pra dados internacionais com mais confiabilidade.

pandas_datareader: o hub de múltiplas fontes

O pandas_datareader funciona como um hub que conecta múltiplas fontes de dados e retorna tudo como DataFrame do pandas. Ele suporta Yahoo Finance, World Bank, FRED (Federal Reserve) e outras fontes:

pip install pandas-datareader

import pandas_datareader as pdr
import datetime

# Dados do World Bank (PIB do Brasil)
pib_brasil = pdr.get_data_world_bank('BR', 'NY.GDP.MKTP.CD',
                                      start=2000, end=2024)

# Dados do FRED (taxa de juros americana)
fed_rate = pdr.get_data_fred('FEDFUNDS',
                              start=datetime.datetime(2020, 1, 1))

Pra análise macro, essa biblioteca é poderosa. Você consegue correlacionar Selic com Fed Funds Rate, PIB brasileiro com performance do Ibovespa, tudo em poucas linhas.

Calculando indicadores técnicos em Python

Ter os dados históricos é o primeiro passo. O segundo é calcular os indicadores que você usa na sua análise. Python tem duas bibliotecas principais pra isso.

pandas-ta: simples e sem dependências complexas

O pandas-ta é a opção mais amigável. Funciona diretamente sobre DataFrames e tem mais de 130 indicadores implementados:

pip install pandas-ta

import yfinance as yf
import pandas_ta as ta

# Baixar dados
df = yf.download("PETR4.SA", period="6mo")

# Calcular RSI (14 períodos)
df['RSI'] = ta.rsi(df['Close'], length=14)

# Calcular MACD
macd = ta.macd(df['Close'])
df = df.join(macd)

# Médias móveis
df['SMA_20'] = ta.sma(df['Close'], length=20)
df['EMA_50'] = ta.ema(df['Close'], length=50)

# Bandas de Bollinger
bbands = ta.bbands(df['Close'], length=20)
df = df.join(bbands)

print(df.tail())

Pra quem já tem familiaridade com os conceitos de análise técnica, ver esses indicadores sendo calculados automaticamente no Python é uma revelação. Você para de depender de plataformas que às vezes travam, e começa a ter controle total sobre o cálculo.

TA-Lib: a biblioteca de referência dos quants

O TA-Lib é a biblioteca técnica de referência do mercado, escrita em C com wrapper Python. Mais rápida que o pandas-ta pra volumes grandes de dados, mas a instalação é mais trabalhosa (precisa das dependências C instaladas no sistema).

import talib
import numpy as np

close = df['Close'].values

# RSI
rsi = talib.RSI(close, timeperiod=14)

# MACD
macd, signal, hist = talib.MACD(close,
                                  fastperiod=12,
                                  slowperiod=26,
                                  signalperiod=9)

# Reconhecimento de padrão de candlestick
doji = talib.CDLDOJI(df['Open'].values,
                     df['High'].values,
                     df['Low'].values,
                     df['Close'].values)

O reconhecimento automático de padrões de candlestick do TA-Lib é especialmente útil. Você pode varrer anos de dados e identificar automaticamente todos os Doji, Engolfo, Martelo e outros padrões, sem precisar analisar gráfico por gráfico.

Backtesting: como testar sua estratégia antes de arriscar dinheiro real

Aqui é onde as coisas ficam sérias. De nada adianta calcular indicadores se você não consegue testar se a estratégia funcionou no passado. Backtesting é a etapa mais importante antes de automatizar qualquer operação real.

Para uma visão completa sobre backtesting e suas limitações, vale ler nosso artigo sobre como testar estratégias de trading com backtesting.

vectorbt: backtesting rápido e vetorizado

O vectorbt é a opção mais moderna e rápida pra backtesting em Python. Ele usa operações vetorizadas do NumPy, o que significa que você consegue testar milhares de combinações de parâmetros em segundos:

pip install vectorbt

import vectorbt as vbt
import yfinance as yf

# Baixar dados
price = yf.download("PETR4.SA", start="2020-01-01")['Close']

# Estratégia simples: cruzamento de médias móveis
fast_ma = vbt.MA.run(price, window=20)
slow_ma = vbt.MA.run(price, window=50)

# Gerar sinais
entries = fast_ma.ma_above(slow_ma)  # Compra quando MA20 > MA50
exits = fast_ma.ma_below(slow_ma)    # Vende quando MA20 < MA50

# Rodar o backtest
portfolio = vbt.Portfolio.from_signals(price, entries, exits,
                                        init_cash=10000,
                                        fees=0.001)

# Ver resultados
print(portfolio.stats())
portfolio.plot().show()

O output inclui retorno total, Sharpe ratio, máximo drawdown, número de operações e outros métricas essenciais. Tudo calculado em segundos.

backtrader: mais completo, curva de aprendizado maior

O backtrader é mais verboso, mas também mais completo. É ideal pra estratégias complexas com múltiplos ativos, gestão de risco elaborada e simulação de custos operacionais reais:

pip install backtrader

Com o backtrader, você define uma classe Strategy, implementa os métodos next() pra lógica de entrada e saída, e o framework cuida do resto: execução das ordens, tracking da posição, cálculo de P&L. É mais trabalhoso, mas o controle é total.

Se você quer entender mais sobre automação de estratégias, nosso artigo sobre robôs de trading e se vale a pena automatizar operações cobre bem os prós e contras antes de você ir fundo nesse caminho.

API do Tesouro Direto: renda fixa também tem dados pra explorar

Não é só a renda variável que tem APIs disponíveis. O Tesouro Direto disponibiliza dados históricos de preços e taxas de todos os títulos via um arquivo CSV público, atualizado diariamente.

import pandas as pd

# URL pública do Tesouro com dados históricos
url = "https://www.tesourodireto.com.br/json/br/com/b3/tesouro/" \
      "tesouro-direto/1/TesouroDireto_HistoricoTaxaPreco.csv"

# Ler direto com pandas
td = pd.read_csv(url, sep=';', encoding='latin-1',
                  decimal=',', thousands='.')

# Filtrar Tesouro IPCA+ 2029
ipca_2029 = td[td['Tipo Título'] == 'Tesouro IPCA+ 2029']
print(ipca_2029.tail())

Com isso você consegue analisar a evolução das taxas ao longo do tempo, identificar janelas de entrada atraentes e correlacionar com outros eventos macroeconômicos. Muito mais rico do que olhar só o preço atual no site.

Boas práticas: respeitar rate limits e armazenar dados localmente

Antes de sair fazendo requisições em loop, algumas regras importantes que a maioria das pessoas aprende na marra:

Respeite os rate limits

APIs gratuitas têm limites de requisições. O Yahoo Finance não é oficial e pode bloquear seu IP se você fizer muitas requisições rápidas. A Alpha Vantage tem 5 requisições por minuto no plano free. O BCB tem limites generosos, mas ainda existem.

Sempre adicione pausas entre requisições:

import time

tickers = ["PETR4.SA", "VALE3.SA", "ITUB4.SA", "BBDC4.SA", "ABEV3.SA"]

for ticker in tickers:
    dados = yf.download(ticker, period="1y", progress=False)
    # Processar dados...
    time.sleep(1)  # 1 segundo entre cada requisição

Armazene os dados localmente

Baixar os mesmos dados toda vez que você roda o script é ineficiente e desnecessário. Salve os dados localmente e só faça uma atualização incremental quando necessário:

import os
import pandas as pd
import yfinance as yf

def get_data_cached(ticker, period="2y"):
    filename = f"data/{ticker.replace('.', '_')}.parquet"

    if os.path.exists(filename):
        # Carregar dados existentes
        df = pd.read_parquet(filename)

        # Só baixar dados novos desde o último registro
        ultima_data = df.index[-1].strftime('%Y-%m-%d')
        novos = yf.download(ticker, start=ultima_data, progress=False)

        if not novos.empty:
            df = pd.concat([df, novos[novos.index > df.index[-1]]])
            df.to_parquet(filename)
    else:
        os.makedirs("data", exist_ok=True)
        df = yf.download(ticker, period=period, progress=False)
        df.to_parquet(filename)

    return df

O formato Parquet é ideal pra dados financeiros: compacto, rápido de ler e suportado nativamente pelo pandas. Um arquivo Parquet com 10 anos de dados diários de uma ação ocupa menos de 1 MB.

Próximos passos: alertas automáticos e dashboards

Com os dados e indicadores funcionando, o horizonte se abre. Dois caminhos naturais pra quem quer ir além:

Alertas automáticos

Você pode criar um script que roda diariamente e envia alertas quando uma ação cruza um nível técnico importante. Usando Python com a biblioteca smtplib (e-mail) ou a API do Telegram, você recebe notificações automáticas:

import smtplib

def enviar_alerta(ativo, mensagem):
    # Configurar SMTP (Gmail, por exemplo)
    server = smtplib.SMTP('smtp.gmail.com', 587)
    server.starttls()
    server.login("seu_email@gmail.com", "sua_senha_app")

    msg = f"Subject: Alerta {ativo}\n\n{mensagem}"
    server.sendmail("seu_email@gmail.com",
                    "destino@gmail.com", msg)
    server.quit()

# Verificar condição e alertar
if rsi_atual < 30:
    enviar_alerta("PETR4", f"RSI em sobrevenda: {rsi_atual:.1f}")

Dashboards com Plotly e Dash

O Plotly gera gráficos interativos de altíssima qualidade, e o Dash permite criar dashboards web completos sem precisar de HTML ou JavaScript. Você pode montar um painel com gráfico de preços, volume, indicadores e tabela de operações, tudo rodando no seu browser:

import plotly.graph_objects as go

fig = go.Figure(data=[go.Candlestick(
    x=df.index,
    open=df['Open'],
    high=df['High'],
    low=df['Low'],
    close=df['Close']
)])

fig.add_trace(go.Scatter(x=df.index, y=df['SMA_20'],
                          name='SMA 20', line=dict(color='blue')))

fig.update_layout(title='PETR4 - Gráfico Diário',
                   xaxis_title='Data',
                   yaxis_title='Preço (R$)')

fig.show()

Pra quem quer aprofundar mais no tema de inteligência artificial no mercado financeiro, nosso artigo sobre como usar IA no trading explora como algoritmos de machine learning estão sendo aplicados pra análise de mercado.

Uma alternativa pra quem não quer programar

Agora, vale ser honesto: nem todo trader quer ou precisa programar. Se o objetivo é ter acesso a análises avançadas sem escrever uma linha de código, o terminal web da Traders com inteligência artificial já entrega muito disso pronto. São cotações em tempo real de mais de 20 mil ativos, indicadores técnicos, dados fundamentalistas e análises com IA integrada, tudo sem precisar instalar Python nem configurar nada. É uma opção válida especialmente pra quem quer agilidade sem a curva de aprendizado técnico.

Dito isso, programar suas próprias análises tem um valor que vai além da praticidade: você entende o que está calculando, consegue personalizar tudo e não fica dependente de nenhuma plataforma específica. Os dois caminhos têm seu lugar.

Conclusão: por onde começar

Se você está começando agora com APIs financeiras em Python, o caminho mais direto é:

Primeiro, instale o yfinance e pandas-ta. Baixe dados históricos de uma ação que você acompanha e calcule RSI e médias móveis. Visualize com matplotlib ou plotly. Isso já é suficiente pra você entender o fluxo básico.

Segundo, experimente o vectorbt pra um backtest simples de cruzamento de médias. Veja o resultado, entenda as métricas e comece a questionar se a estratégia que você usa na prática realmente tem edge histórico.

Terceiro, adicione dados macroeconômicos do Banco Central. Cruze Selic com Ibovespa. Veja câmbio vs. ações exportadoras. Você vai descobrir correlações que nunca tinha notado.

Python no mercado financeiro não é sobre virar engenheiro de software. É sobre ter ferramentas melhores pra tomar decisões mais informadas. E com os recursos disponíveis hoje, nunca foi tão acessível.

Quer dar o próximo passo nos investimentos? Acesse www.traders.com.br e abra sua conta na Traders, a corretora feita por traders pra traders.

---