brapi logobrapi
Obter Chave de API
Voltar para o blog

API brapi.dev 2025: Guia Completo para Desenvolvedores de FinTech

Domine a API brapi.dev! Tutorial completo para desenvolvedores: cotações tempo real, análise fundamentalista, integração JavaScript/Python. Documentação prática ✓

Categoria:Desenvolvimento e APIs • Tutoriais de Integração
28 min
Atualizado em:
Expertise: Desenvolvimento de aplicações financeiras com 8+ anos de experiência
Tags:
APIDesenvolvimentoIntegraçãoDados FinanceirosB3JavaScriptPythonFinTech

Neste artigo

Como Usar a API da brapi.dev para Análise de Ações: Guia Completo para Desenvolvedores

A API da brapi.dev é a solução mais completa para acessar dados financeiros do mercado brasileiro. Neste guia, você aprenderá como integrar nossa API em suas aplicações, desde consultas básicas até análises avançadas de ações, FIIs e criptomoedas.

Publicado em 21 de janeiro, 2024
porEquipe brapi.dev

Por que Escolher a API da brapi.dev?

A API da brapi.dev oferece acesso simplificado e confiável aos dados financeiros do mercado brasileiro, eliminando a complexidade de coletar e processar informações de múltiplas fontes.

Principais Vantagens

1. Dados Abrangentes

  • ✅ Ações da B3 (Bovespa)
  • ✅ Fundos Imobiliários (FIIs)
  • ✅ Índices (Ibovespa, IFIX, etc.)
  • ✅ Criptomoedas
  • ✅ Moedas e câmbio
  • ✅ Indicadores econômicos (IPCA, SELIC, IGP-M)

2. Facilidade de Integração

  • API REST simples e intuitiva
  • Documentação completa
  • Exemplos em múltiplas linguagens
  • SDKs oficiais disponíveis

3. Dados Confiáveis

  • Fontes oficiais (B3, CVM, Banco Central)
  • Atualizações em tempo real
  • Histórico completo disponível
  • 99.9% de uptime

Começando com a API

1. Obtendo sua Chave de API

Primeiro, crie sua conta gratuita na brapi.dev:

# Teste básico sem autenticação (limitado)
curl "https://brapi.dev/api/quote/PETR4"

# Com token de acesso (recomendado)
curl "https://brapi.dev/api/quote/PETR4?token=SEU_TOKEN"

2. Estrutura Básica das Respostas

Todas as respostas seguem um padrão consistente:

{
  "results": [
    {
      "symbol": "PETR4",
      "shortName": "PETROBRAS PN",
      "longName": "Petróleo Brasileiro S.A. - Petrobras",
      "currency": "BRL",
      "regularMarketPrice": 35.20,
      "regularMarketDayHigh": 35.85,
      "regularMarketDayLow": 34.90,
      "regularMarketVolume": 42858200,
      "regularMarketChange": 0.15,
      "regularMarketChangePercent": 0.427,
      "validRanges": ["1d", "5d", "1mo", "3mo", "6mo", "1y", "2y", "5y", "10y", "ytd", "max"],
      "validIntervals": ["1m", "2m", "5m", "15m", "30m", "60m", "90m", "1h", "1d", "5d", "1wk", "1mo", "3mo"]
    }
  ],
  "requestedAt": "2024-01-21T10:30:00.000Z",
  "took": "45ms"
}

Consultas Básicas de Ações

Cotação Atual

// JavaScript/Node.js
const obterCotacao = async (ticker) => {
  try {
    const response = await fetch(`https://brapi.dev/api/quote/${ticker}?token=SEU_TOKEN`);
    const data = await response.json();
    
    const acao = data.results[0];
    return {
      simbolo: acao.symbol,
      preco: acao.regularMarketPrice,
      variacao: acao.regularMarketChangePercent,
      volume: acao.regularMarketVolume,
      atualizadoEm: data.requestedAt
    };
  } catch (error) {
    console.error('Erro ao buscar cotação:', error);
  }
};

// Exemplo de uso
const petr4 = await obterCotacao('PETR4');
console.log(`${petr4.simbolo}: R$ ${petr4.preco} (${petr4.variacao.toFixed(2)}%)`);

Múltiplas Ações

# Python
import requests
import json

def obter_multiplas_cotacoes(tickers, token):
    """Obtém cotações de múltiplas ações em uma única requisição"""
    tickers_str = ','.join(tickers)
    url = f"https://brapi.dev/api/quote/{tickers_str}?token={token}"
    
    response = requests.get(url)
    data = response.json()
    
    cotacoes = {}
    for acao in data['results']:
        cotacoes[acao['symbol']] = {
            'preco': acao['regularMarketPrice'],
            'variacao': acao['regularMarketChangePercent'],
            'volume': acao['regularMarketVolume']
        }
    
    return cotacoes

# Exemplo de uso
tickers = ['PETR4', 'VALE3', 'ITUB4', 'BBDC4']
token = 'SEU_TOKEN'
cotacoes = obter_multiplas_cotacoes(tickers, token)

for ticker, dados in cotacoes.items():
    print(f"{ticker}: R$ {dados['preco']:.2f} ({dados['variacao']:+.2f}%)")

Dados Históricos e Gráficos

Consultando Histórico OHLCV

const obterHistorico = async (ticker, periodo = '1y', intervalo = '1d') => {
  const url = `https://brapi.dev/api/quote/${ticker}?range=${periodo}&interval=${intervalo}&token=SEU_TOKEN`;
  
  const response = await fetch(url);
  const data = await response.json();
  
  const acao = data.results[0];
  
  return {
    symbol: acao.symbol,
    historicalDataPrice: acao.historicalDataPrice.map(item => ({
      date: new Date(item.date * 1000),
      open: item.open,
      high: item.high,
      low: item.low,
      close: item.close,
      volume: item.volume,
      adjustedClose: item.adjustedClose
    }))
  };
};

// Criando gráfico com Chart.js
const criarGrafico = async (ticker) => {
  const dados = await obterHistorico(ticker, '6mo', '1d');
  
  const ctx = document.getElementById('grafico').getContext('2d');
  new Chart(ctx, {
    type: 'line',
    data: {
      labels: dados.historicalDataPrice.map(d => d.date.toLocaleDateString()),
      datasets: [{
        label: ticker,
        data: dados.historicalDataPrice.map(d => d.close),
        borderColor: 'rgb(75, 192, 192)',
        tension: 0.1
      }]
    },
    options: {
      responsive: true,
      scales: {
        y: {
          beginAtZero: false
        }
      }
    }
  });
};

Análise Técnica Básica

import pandas as pd
import numpy as np

def calcular_medias_moveis(ticker, token):
    """Calcula médias móveis e indicadores técnicos"""
    
    # Obter dados históricos
    url = f"https://brapi.dev/api/quote/{ticker}?range=1y&interval=1d&token={token}"
    response = requests.get(url)
    data = response.json()
    
    # Converter para DataFrame
    historico = data['results'][0]['historicalDataPrice']
    df = pd.DataFrame(historico)
    df['date'] = pd.to_datetime(df['date'], unit='s')
    df.set_index('date', inplace=True)
    
    # Calcular médias móveis
    df['MM9'] = df['close'].rolling(window=9).mean()
    df['MM21'] = df['close'].rolling(window=21).mean()
    df['MM50'] = df['close'].rolling(window=50).mean()
    df['MM200'] = df['close'].rolling(window=200).mean()
    
    # RSI
    delta = df['close'].diff()
    gain = (delta.where(delta > 0, 0)).rolling(window=14).mean()
    loss = (-delta.where(delta < 0, 0)).rolling(window=14).mean()
    rs = gain / loss
    df['RSI'] = 100 - (100 / (1 + rs))
    
    # Bandas de Bollinger
    df['BB_MA'] = df['close'].rolling(window=20).mean()
    bb_std = df['close'].rolling(window=20).std()
    df['BB_Upper'] = df['BB_MA'] + (bb_std * 2)
    df['BB_Lower'] = df['BB_MA'] - (bb_std * 2)
    
    return df

# Exemplo de uso
df_petr4 = calcular_medias_moveis('PETR4', 'SEU_TOKEN')
print(f"RSI atual PETR4: {df_petr4['RSI'].iloc[-1]:.2f}")

Módulos Avançados da API

Dados Fundamentalistas

A brapi.dev oferece módulos especializados para análise fundamentalista:

const obterDadosFundamentalistas = async (ticker) => {
  const modules = [
    'defaultKeyStatistics',
    'financialData', 
    'summaryProfile',
    'balanceSheetHistory',
    'incomeStatementHistory'
  ].join(',');
  
  const url = `https://brapi.dev/api/quote/${ticker}?modules=${modules}&token=SEU_TOKEN`;
  
  const response = await fetch(url);
  const data = await response.json();
  const acao = data.results[0];
  
  return {
    empresa: {
      nome: acao.longName,
      setor: acao.summaryProfile?.sector,
      industria: acao.summaryProfile?.industry,
      funcionarios: acao.summaryProfile?.fullTimeEmployees,
      site: acao.summaryProfile?.website
    },
    indicadores: {
      pl: acao.defaultKeyStatistics?.forwardPE,
      pvp: acao.defaultKeyStatistics?.priceToBook,
      dy: acao.defaultKeyStatistics?.dividendYield,
      roe: acao.financialData?.returnOnEquity,
      roa: acao.financialData?.returnOnAssets,
      margemLiquida: acao.financialData?.profitMargins
    },
    valuation: {
      marketCap: acao.defaultKeyStatistics?.marketCap,
      enterpriseValue: acao.defaultKeyStatistics?.enterpriseValue,
      evEbitda: acao.defaultKeyStatistics?.enterpriseToEbitda,
      pegRatio: acao.defaultKeyStatistics?.pegRatio
    }
  };
};

// Exemplo de uso
const analise = await obterDadosFundamentalistas('EGIE3');
console.log('Análise Fundamentalista EGIE3:');
console.log(`ROE: ${(analise.indicadores.roe * 100).toFixed(1)}%`);
console.log(`P/L: ${analise.indicadores.pl?.toFixed(1)}x`);
console.log(`DY: ${(analise.indicadores.dy * 100).toFixed(1)}%`);

Screening de Ações

def screening_acoes(criterios, token):
    """
    Faz screening de ações baseado em critérios fundamentalistas
    """
    # Lista de ações para analisar (top 100 por volume)
    tickers = [
        'PETR4', 'VALE3', 'ITUB4', 'BBDC4', 'ABEV3', 'BBAS3', 'WEGE3', 'EGIE3',
        'RENT3', 'LREN3', 'MGLU3', 'RAIL3', 'VIVT3', 'KLBN11', 'SBSP3', 'CPLE6',
        'GGBR4', 'USIM5', 'SUZB3', 'TOTS3', 'ASAI3', 'PRIO3', 'RDOR3', 'HAPV3'
    ]
    
    oportunidades = []
    modules = 'defaultKeyStatistics,financialData'
    
    for ticker in tickers:
        try:
            url = f"https://brapi.dev/api/quote/{ticker}?modules={modules}&token={token}"
            response = requests.get(url)
            data = response.json()
            acao = data['results'][0]
            
            # Extrair indicadores
            stats = acao.get('defaultKeyStatistics', {})
            financials = acao.get('financialData', {})
            
            pl = stats.get('forwardPE', 0)
            pvp = stats.get('priceToBook', 0)
            dy = stats.get('dividendYield', 0)
            roe = financials.get('returnOnEquity', 0)
            
            # Aplicar critérios
            if (pl > 0 and pl < criterios['pl_max'] and
                pvp > 0 and pvp < criterios['pvp_max'] and
                dy > criterios['dy_min'] and
                roe > criterios['roe_min']):
                
                oportunidades.append({
                    'ticker': ticker,
                    'nome': acao['shortName'],
                    'preco': acao['regularMarketPrice'],
                    'pl': pl,
                    'pvp': pvp,
                    'dy': dy * 100,
                    'roe': roe * 100,
                    'score': calcular_score(pl, pvp, dy, roe)
                })
                
        except Exception as e:
            print(f"Erro ao processar {ticker}: {e}")
            continue
    
    # Ordenar por score
    return sorted(oportunidades, key=lambda x: x['score'], reverse=True)

def calcular_score(pl, pvp, dy, roe):
    """Calcula score de atratividade (0-100)"""
    score = 0
    
    # P/L baixo é melhor
    if pl < 10: score += 25
    elif pl < 15: score += 15
    elif pl < 20: score += 5
    
    # P/VP baixo é melhor  
    if pvp < 1: score += 25
    elif pvp < 1.5: score += 15
    elif pvp < 2: score += 5
    
    # DY alto é melhor
    if dy > 0.08: score += 25
    elif dy > 0.05: score += 15
    elif dy > 0.03: score += 5
    
    # ROE alto é melhor
    if roe > 0.20: score += 25
    elif roe > 0.15: score += 15
    elif roe > 0.10: score += 5
    
    return score

# Exemplo de uso
criterios = {
    'pl_max': 15,
    'pvp_max': 2,
    'dy_min': 0.03,  # 3%
    'roe_min': 0.10  # 10%
}

resultados = screening_acoes(criterios, 'SEU_TOKEN')

print("🎯 Top 10 Oportunidades:")
for i, acao in enumerate(resultados[:10], 1):
    print(f"{i:2d}. {acao['ticker']} - {acao['nome']}")
    print(f"    Preço: R$ {acao['preco']:.2f} | P/L: {acao['pl']:.1f} | DY: {acao['dy']:.1f}% | Score: {acao['score']}")

Integrações Avançadas

Dashboard em React

import React, { useState, useEffect } from 'react';
import { LineChart, Line, XAxis, YAxis, CartesianGrid, Tooltip, Legend } from 'recharts';

const DashboardAcoes = () => {
  const [watchlist, setWatchlist] = useState(['PETR4', 'VALE3', 'ITUB4']);
  const [cotacoes, setCotacoes] = useState([]);
  const [loading, setLoading] = useState(true);

  useEffect(() => {
    const buscarCotacoes = async () => {
      try {
        const tickers = watchlist.join(',');
        const response = await fetch(`https://brapi.dev/api/quote/${tickers}?token=${process.env.REACT_APP_BRAPI_TOKEN}`);
        const data = await response.json();
        
        setCotacoes(data.results.map(acao => ({
          symbol: acao.symbol,
          name: acao.shortName,
          price: acao.regularMarketPrice,
          change: acao.regularMarketChange,
          changePercent: acao.regularMarketChangePercent,
          volume: acao.regularMarketVolume
        })));
      } catch (error) {
        console.error('Erro ao buscar cotações:', error);
      } finally {
        setLoading(false);
      }
    };

    buscarCotacoes();
    const interval = setInterval(buscarCotacoes, 60000); // Atualizar a cada minuto

    return () => clearInterval(interval);
  }, [watchlist]);

  const adicionarAcao = (ticker) => {
    if (!watchlist.includes(ticker)) {
      setWatchlist([...watchlist, ticker]);
    }
  };

  if (loading) return <div>Carregando...</div>;

  return (
    <div className="dashboard">
      <h1>Dashboard de Ações</h1>
      
      <div className="watchlist">
        <h2>Watchlist</h2>
        <div className="acoes-grid">
          {cotacoes.map(acao => (
            <div key={acao.symbol} className="acao-card">
              <h3>{acao.symbol}</h3>
              <p className="nome">{acao.name}</p>
              <p className="preco">R$ {acao.price.toFixed(2)}</p>
              <p className={`variacao ${acao.changePercent >= 0 ? 'positiva' : 'negativa'}`}>
                {acao.changePercent >= 0 ? '+' : ''}{acao.changePercent.toFixed(2)}%
              </p>
              <p className="volume">Vol: {(acao.volume / 1000000).toFixed(1)}M</p>
            </div>
          ))}
        </div>
      </div>
      
      <div className="controles">
        <input 
          type="text" 
          placeholder="Digite um ticker (ex: PETR4)"
          onKeyPress={(e) => {
            if (e.key === 'Enter') {
              adicionarAcao(e.target.value.toUpperCase());
              e.target.value = '';
            }
          }}
        />
      </div>
    </div>
  );
};

export default DashboardAcoes;

Webhook para Alertas

from flask import Flask, request, jsonify
import requests
import json

app = Flask(__name__)

def verificar_alertas():
    """Verifica condições de alerta nas ações monitoradas"""
    alertas = []
    watchlist = [
        {'ticker': 'PETR4', 'preco_alvo': 40.00, 'tipo': 'acima'},
        {'ticker': 'VALE3', 'preco_alvo': 60.00, 'tipo': 'abaixo'},
        {'ticker': 'ITUB4', 'preco_alvo': 25.00, 'tipo': 'acima'}
    ]
    
    for alerta in watchlist:
        ticker = alerta['ticker']
        url = f"https://brapi.dev/api/quote/{ticker}?token=SEU_TOKEN"
        
        response = requests.get(url)
        data = response.json()
        acao = data['results'][0]
        
        preco_atual = acao['regularMarketPrice']
        preco_alvo = alerta['preco_alvo']
        
        disparar = False
        if alerta['tipo'] == 'acima' and preco_atual >= preco_alvo:
            disparar = True
        elif alerta['tipo'] == 'abaixo' and preco_atual <= preco_alvo:
            disparar = True
            
        if disparar:
            alertas.append({
                'ticker': ticker,
                'preco_atual': preco_atual,
                'preco_alvo': preco_alvo,
                'tipo': alerta['tipo'],
                'variacao': acao['regularMarketChangePercent']
            })
    
    return alertas

def enviar_telegram(mensagem):
    """Envia alerta via Telegram"""
    bot_token = 'SEU_BOT_TOKEN'
    chat_id = 'SEU_CHAT_ID'
    
    url = f"https://api.telegram.org/bot{bot_token}/sendMessage"
    payload = {
        'chat_id': chat_id,
        'text': mensagem,
        'parse_mode': 'HTML'
    }
    
    requests.post(url, json=payload)

@app.route('/check-alerts', methods=['GET'])
def check_alerts():
    """Endpoint para verificar alertas"""
    alertas = verificar_alertas()
    
    if alertas:
        for alerta in alertas:
            mensagem = f"""
🚨 <b>ALERTA DE PREÇO</b>

📊 <b>{alerta['ticker']}</b>
💰 Preço atual: R$ {alerta['preco_atual']:.2f}
🎯 Preço alvo: R$ {alerta['preco_alvo']:.2f}
📈 Variação: {alerta['variacao']:+.2f}%

Condição: Preço {alerta['tipo']} do alvo
"""
            enviar_telegram(mensagem)
    
    return jsonify({
        'alertas_disparados': len(alertas),
        'alertas': alertas
    })

if __name__ == '__main__':
    app.run(debug=True)

Exemplos de Aplicações Práticas

1. Bot de Trading Automatizado

import time
import pandas as pd
from datetime import datetime, timedelta

class BotTradingBrapi:
    def __init__(self, token, telegram_token=None):
        self.token = token
        self.telegram_token = telegram_token
        self.posicoes = {}
        self.historico_ordens = []
        
    def obter_dados_acao(self, ticker, periodo='1mo'):
        """Obtém dados históricos para análise"""
        url = f"https://brapi.dev/api/quote/{ticker}?range={periodo}&interval=1d&token={self.token}"
        response = requests.get(url)
        data = response.json()
        
        historico = data['results'][0]['historicalDataPrice']
        df = pd.DataFrame(historico)
        df['date'] = pd.to_datetime(df['date'], unit='s')
        return df
        
    def calcular_sinais(self, df):
        """Calcula sinais de compra/venda usando médias móveis"""
        df['MM9'] = df['close'].rolling(9).mean()
        df['MM21'] = df['close'].rolling(21).mean()
        
        # Sinal de compra: MM9 cruza MM21 para cima
        df['sinal_compra'] = (df['MM9'] > df['MM21']) & (df['MM9'].shift(1) <= df['MM21'].shift(1))
        
        # Sinal de venda: MM9 cruza MM21 para baixo  
        df['sinal_venda'] = (df['MM9'] < df['MM21']) & (df['MM9'].shift(1) >= df['MM21'].shift(1))
        
        return df
        
    def verificar_oportunidades(self, watchlist):
        """Verifica oportunidades na watchlist"""
        oportunidades = []
        
        for ticker in watchlist:
            df = self.obter_dados_acao(ticker)
            df = self.calcular_sinais(df)
            
            ultimo_sinal_compra = df[df['sinal_compra']].iloc[-1:] if len(df[df['sinal_compra']]) > 0 else None
            ultimo_sinal_venda = df[df['sinal_venda']].iloc[-1:] if len(df[df['sinal_venda']]) > 0 else None
            
            # Verificar se há sinal recente (últimos 3 dias)
            tres_dias_atras = datetime.now() - timedelta(days=3)
            
            if ultimo_sinal_compra is not None:
                data_sinal = ultimo_sinal_compra['date'].iloc[0]
                if data_sinal >= tres_dias_atras:
                    oportunidades.append({
                        'ticker': ticker,
                        'acao': 'COMPRA',
                        'preco': df['close'].iloc[-1],
                        'data_sinal': data_sinal
                    })
                    
            if ultimo_sinal_venda is not None:
                data_sinal = ultimo_sinal_venda['date'].iloc[0]
                if data_sinal >= tres_dias_atras:
                    oportunidades.append({
                        'ticker': ticker,
                        'acao': 'VENDA', 
                        'preco': df['close'].iloc[-1],
                        'data_sinal': data_sinal
                    })
        
        return oportunidades
        
    def executar_estrategia(self):
        """Executa a estratégia de trading"""
        watchlist = ['PETR4', 'VALE3', 'ITUB4', 'BBDC4', 'WEGE3']
        oportunidades = self.verificar_oportunidades(watchlist)
        
        for opp in oportunidades:
            if opp['acao'] == 'COMPRA' and opp['ticker'] not in self.posicoes:
                print(f"🟢 SINAL DE COMPRA: {opp['ticker']} a R$ {opp['preco']:.2f}")
                # Aqui integraria com broker para execução real
                
            elif opp['acao'] == 'VENDA' and opp['ticker'] in self.posicoes:
                print(f"🔴 SINAL DE VENDA: {opp['ticker']} a R$ {opp['preco']:.2f}")
                # Aqui integraria com broker para execução real
                
        return oportunidades

# Uso do bot
bot = BotTradingBrapi('SEU_TOKEN')
while True:
    oportunidades = bot.executar_estrategia()
    time.sleep(300)  # Aguardar 5 minutos

2. Relatório Automatizado de Carteira

def gerar_relatorio_carteira(carteira, token):
    """Gera relatório completo da carteira"""
    relatorio = {
        'data_relatorio': datetime.now().strftime('%d/%m/%Y %H:%M'),
        'total_investido': 0,
        'valor_atual': 0,
        'resultado_total': 0,
        'rendimento_percentual': 0,
        'acoes': []
    }
    
    for item in carteira:
        ticker = item['ticker']
        quantidade = item['quantidade']
        preco_medio = item['preco_medio']
        
        # Buscar cotação atual
        url = f"https://brapi.dev/api/quote/{ticker}?modules=defaultKeyStatistics&token={token}"
        response = requests.get(url)
        data = response.json()
        acao = data['results'][0]
        
        preco_atual = acao['regularMarketPrice']
        dy = acao.get('defaultKeyStatistics', {}).get('dividendYield', 0) or 0
        
        # Calcular métricas
        investido = quantidade * preco_medio
        valor_atual = quantidade * preco_atual
        resultado = valor_atual - investido
        rendimento = (resultado / investido) * 100
        
        relatorio['total_investido'] += investido
        relatorio['valor_atual'] += valor_atual
        relatorio['resultado_total'] += resultado
        
        relatorio['acoes'].append({
            'ticker': ticker,
            'nome': acao['shortName'],
            'quantidade': quantidade,
            'preco_medio': preco_medio,
            'preco_atual': preco_atual,
            'investido': investido,
            'valor_atual': valor_atual,
            'resultado': resultado,
            'rendimento_percentual': rendimento,
            'dividend_yield': dy * 100,
            'participacao': 0  # Será calculado depois
        })
    
    # Calcular rendimento total e participações
    if relatorio['total_investido'] > 0:
        relatorio['rendimento_percentual'] = (relatorio['resultado_total'] / relatorio['total_investido']) * 100
        
        for acao in relatorio['acoes']:
            acao['participacao'] = (acao['valor_atual'] / relatorio['valor_atual']) * 100
    
    return relatorio

def formatar_relatorio_html(relatorio):
    """Converte relatório para HTML"""
    html = f"""
    <html>
    <head>
        <title>Relatório de Carteira - {relatorio['data_relatorio']}</title>
        <style>
            body {{ font-family: Arial, sans-serif; margin: 20px; }}
            .header {{ background: #2c3e50; color: white; padding: 20px; text-align: center; }}
            .resumo {{ background: #ecf0f1; padding: 15px; margin: 20px 0; }}
            table {{ width: 100%; border-collapse: collapse; margin: 20px 0; }}
            th, td {{ border: 1px solid #ddd; padding: 12px; text-align: left; }}
            th {{ background-color: #34495e; color: white; }}
            .positivo {{ color: #27ae60; }}
            .negativo {{ color: #e74c3c; }}
        </style>
    </head>
    <body>
        <div class="header">
            <h1>Relatório de Carteira</h1>
            <p>{relatorio['data_relatorio']}</p>
        </div>
        
        <div class="resumo">
            <h2>Resumo Geral</h2>
            <p><strong>Total Investido:</strong> R$ {relatorio['total_investido']:,.2f}</p>
            <p><strong>Valor Atual:</strong> R$ {relatorio['valor_atual']:,.2f}</p>
            <p><strong>Resultado:</strong> 
                <span class="{'positivo' if relatorio['resultado_total'] >= 0 else 'negativo'}">
                    R$ {relatorio['resultado_total']:+,.2f} ({relatorio['rendimento_percentual']:+.2f}%)
                </span>
            </p>
        </div>
        
        <h2>Detalhamento por Ação</h2>
        <table>
            <thead>
                <tr>
                    <th>Ticker</th>
                    <th>Nome</th>
                    <th>Qtd</th>
                    <th>Preço Médio</th>
                    <th>Preço Atual</th>
                    <th>Investido</th>
                    <th>Valor Atual</th>
                    <th>Resultado</th>
                    <th>Rendimento</th>
                    <th>Participação</th>
                    <th>DY</th>
                </tr>
            </thead>
            <tbody>
    """
    
    for acao in relatorio['acoes']:
        classe_resultado = 'positivo' if acao['resultado'] >= 0 else 'negativo'
        html += f"""
                <tr>
                    <td><strong>{acao['ticker']}</strong></td>
                    <td>{acao['nome']}</td>
                    <td>{acao['quantidade']}</td>
                    <td>R$ {acao['preco_medio']:.2f}</td>
                    <td>R$ {acao['preco_atual']:.2f}</td>
                    <td>R$ {acao['investido']:,.2f}</td>
                    <td>R$ {acao['valor_atual']:,.2f}</td>
                    <td class="{classe_resultado}">R$ {acao['resultado']:+,.2f}</td>
                    <td class="{classe_resultado}">{acao['rendimento_percentual']:+.2f}%</td>
                    <td>{acao['participacao']:.1f}%</td>
                    <td>{acao['dividend_yield']:.2f}%</td>
                </tr>
        """
    
    html += """
            </tbody>
        </table>
    </body>
    </html>
    """
    
    return html

# Exemplo de uso
carteira_exemplo = [
    {'ticker': 'PETR4', 'quantidade': 100, 'preco_medio': 32.50},
    {'ticker': 'VALE3', 'quantidade': 50, 'preco_medio': 65.80},
    {'ticker': 'ITUB4', 'quantidade': 200, 'preco_medio': 24.30},
    {'ticker': 'WEGE3', 'quantidade': 80, 'preco_medio': 45.20}
]

relatorio = gerar_relatorio_carteira(carteira_exemplo, 'SEU_TOKEN')
html = formatar_relatorio_html(relatorio)

# Salvar relatório
with open(f"relatorio_carteira_{datetime.now().strftime('%Y%m%d')}.html", 'w', encoding='utf-8') as f:
    f.write(html)

print("Relatório gerado com sucesso!")

Monitoramento e Performance

Rate Limits e Otimização

class BrapiClient {
  constructor(token) {
    this.token = token;
    this.baseURL = 'https://brapi.dev/api';
    this.requestQueue = [];
    this.processing = false;
    this.rateLimit = 100; // requests por minuto
    this.requestInterval = 60000 / this.rateLimit; // ms entre requests
  }
  
  async request(endpoint, params = {}) {
    return new Promise((resolve, reject) => {
      this.requestQueue.push({ endpoint, params, resolve, reject });
      this.processQueue();
    });
  }
  
  async processQueue() {
    if (this.processing || this.requestQueue.length === 0) return;
    
    this.processing = true;
    
    while (this.requestQueue.length > 0) {
      const { endpoint, params, resolve, reject } = this.requestQueue.shift();
      
      try {
        const queryParams = new URLSearchParams({
          token: this.token,
          ...params
        });
        
        const response = await fetch(`${this.baseURL}${endpoint}?${queryParams}`);
        const data = await response.json();
        
        resolve(data);
      } catch (error) {
        reject(error);
      }
      
      // Respeitar rate limit
      await new Promise(resolve => setTimeout(resolve, this.requestInterval));
    }
    
    this.processing = false;
  }
  
  async quote(ticker, modules = []) {
    const params = modules.length > 0 ? { modules: modules.join(',') } : {};
    return this.request(`/quote/${ticker}`, params);
  }
  
  async multipleQuotes(tickers, modules = []) {
    const tickerString = Array.isArray(tickers) ? tickers.join(',') : tickers;
    const params = modules.length > 0 ? { modules: modules.join(',') } : {};
    return this.request(`/quote/${tickerString}`, params);
  }
}

// Uso do cliente otimizado
const client = new BrapiClient('SEU_TOKEN');

// Requests serão automaticamente enfileirados e respeitarão rate limits
const petr4 = await client.quote('PETR4', ['defaultKeyStatistics']);
const multiplas = await client.multipleQuotes(['VALE3', 'ITUB4', 'BBDC4']);

Conclusão

A API da brapi.dev oferece uma solução completa e confiável para desenvolvedores que precisam integrar dados financeiros do mercado brasileiro em suas aplicações. Com documentação clara, múltiplos módulos especializados e exemplos práticos, é possível construir desde dashboards simples até sistemas complexos de análise e trading.

Próximos Passos:

  1. Crie sua conta e obtenha seu token de acesso
  2. Explore a documentação completa com todos os endpoints
  3. Teste os exemplos deste guia em suas aplicações
  4. Acesse nossa plataforma para análises interativas

Recursos Adicionais:

Lembre-se: A brapi.dev está sempre evoluindo. Acompanhe nossas atualizações para descobrir novos recursos e melhorias!

Artigos Relacionados

Análise Fundamentalista

ROIC 2025: Como Calcular Return on Invested Capital com API

Domine o ROIC para análise de eficiência! Aprenda calcular Return on Invested Capital, interpretar resultados e implementar com API brapi. Guia completo ✓

15 min
Trading e Análise

Bolsa em Tempo Real 2025: Como Monitorar Cotações e Oportunidades

Domine o acompanhamento da bolsa em tempo real! Aprenda ferramentas, estratégias, alertas e análise para trading e investimentos na B3. Guia completo ✓

17 min
Análise Financeira

Demonstrativos Financeiros 2025: Como Analisar Saúde de Empresas

Domine análise de demonstrativos financeiros! DRE, Balanço Patrimonial, Fluxo de Caixa e indicadores para avaliar saúde financeira real na B3 ✓

21 min