brapi vs Alpha Vantage 2026: Comparativo Completo de APIs Financeiras

┌─────────────────────────────────────────────────────────────┐
│                    RECOMENDAÇÃO                             │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  Para Mercado Brasileiro → brapi.dev                        │
│  ├─ Cobertura completa B3                                   │
│  ├─ Dados fundamentalistas detalhados                       │
│  ├─ Suporte em português                                    │
│  └─ Melhor custo-benefício para Brasil                      │
│                                                             │
│  Para Mercado Internacional → Alpha Vantage                 │
│  ├─ NYSE, NASDAQ, mercados globais                          │
│  ├─ Forex e Crypto                                          │
│  └─ Indicadores técnicos prontos                            │
│                                                             │
│  Para Ambos → brapi.dev + Alpha Vantage                     │
│  └─ Combine APIs para cobertura completa                    │
│                                                             │
└─────────────────────────────────────────────────────────────┘

import requests

response = requests.get(
    "https://brapi.dev/api/quote/WEGE3",
    headers={"Authorization": "Bearer SEU_TOKEN"}
)
data = response.json()

print(data["results"][0]["regularMarketPrice"])  # 35.42
print(data["results"][0]["sector"])              # "Bens Industriais"

# Tentando buscar ação brasileira
import requests

url = "https://www.alphavantage.co/query"
params = {
    "function": "GLOBAL_QUOTE",
    "symbol": "WEGE3.SAO",  # Precisa adicionar .SAO
    "apikey": "SUA_API_KEY"
}
response = requests.get(url, params=params)
data = response.json()

# Resultado: dados limitados ou indisponíveis
# Muitas ações brasileiras não são encontradas

# FIIs totalmente suportados
response = requests.get(
    "https://brapi.dev/api/quote/MXRF11,HGLG11,XPML11",
    headers={"Authorization": "Bearer SEU_TOKEN"}
)

# Retorna: cotação, dividend yield, P/VP, etc.

# FIIs NÃO suportados
response = requests.get(
    "https://www.alphavantage.co/query",
    params={
        "function": "GLOBAL_QUOTE",
        "symbol": "MXRF11.SAO",
        "apikey": "KEY"
    }
)
# Resultado: Erro ou dados vazios

# Dados fundamentalistas completos
response = requests.get(
    "https://brapi.dev/api/quote/ITUB4?fundamental=true",
    headers={"Authorization": "Bearer SEU_TOKEN"}
)
data = response.json()["results"][0]

# 50+ indicadores disponíveis:
fundamentals = {
    # Valuation
    "P/L": data.get("priceEarnings"),
    "P/VP": data.get("priceToBook"),
    "P/Receita": data.get("priceToSales"),
    "EV/EBITDA": data.get("enterpriseToEbitda"),
    
    # Rentabilidade
    "ROE": data.get("returnOnEquity"),
    "ROA": data.get("returnOnAssets"),
    "ROIC": data.get("returnOnCapital"),
    "Margem Líquida": data.get("netMargin"),
    "Margem EBITDA": data.get("ebitdaMargin"),
    
    # Dividendos
    "Dividend Yield": data.get("dividendYield"),
    "Payout": data.get("payoutRatio"),
    
    # Endividamento
    "Dívida/PL": data.get("debtToEquity"),
    "Dívida/EBITDA": data.get("debtToEbitda"),
    
    # Crescimento
    "Cresc. Receita 5a": data.get("revenueGrowth5y"),
    "Cresc. Lucro 5a": data.get("earningsGrowth5y"),
}

# Alpha Vantage - Overview
response = requests.get(
    "https://www.alphavantage.co/query",
    params={
        "function": "OVERVIEW",
        "symbol": "ITUB4.SAO",
        "apikey": "KEY"
    }
)
# Resultado: Muitos campos vazios ou inexistentes para Brasil

┌────────────────────────────────────────────────────────────┐
│           DADOS FUNDAMENTALISTAS DISPONÍVEIS               │
├────────────────────────────────────────────────────────────┤
│                                                            │
│  Indicador              brapi.dev    Alpha Vantage         │
│  ─────────────────────────────────────────────────────     │
│  P/L                    ✅            ⚠️ (parcial)         │
│  P/VP                   ✅            ❌                    │
│  ROE                    ✅            ❌                    │
│  ROA                    ✅            ❌                    │
│  ROIC                   ✅            ❌                    │
│  Dividend Yield         ✅            ❌                    │
│  Margem Líquida         ✅            ❌                    │
│  Dívida/PL              ✅            ❌                    │
│  EV/EBITDA              ✅            ❌                    │
│  Balanço Patrimonial    ✅            ❌                    │
│  DRE                    ✅            ❌                    │
│  Fluxo de Caixa         ✅            ❌                    │
│                                                            │
│  Total: 50+ indicadores  |  Total: 5-10 indicadores        │
│                                                            │
└────────────────────────────────────────────────────────────┘

# Cenário: 10.000 requisições/mês para dados brasileiros

# brapi.dev
custo_brapi = 39  # R$/mês (Starter)
dados_recebidos = "completos, fundamentalistas, FIIs, BDRs"

# Alpha Vantage
custo_alpha = 49.99 * 5.5  # ~R$ 275/mês (conversão USD)
dados_recebidos = "limitados, sem FIIs, fundamentalistas básicos"

# Economia com brapi.dev
economia_mensal = 275 - 39  # R$ 236/mês
economia_anual = economia_mensal * 12  # R$ 2.832/ano

import time
import requests
import statistics

def benchmark_api(url, headers, iterations=100):
    latencies = []
    for _ in range(iterations):
        start = time.time()
        requests.get(url, headers=headers)
        latencies.append((time.time() - start) * 1000)
    return {
        "avg": statistics.mean(latencies),
        "p50": statistics.median(latencies),
        "p99": statistics.quantile(latencies, 0.99)
    }

# Resultados (servidor em São Paulo)
brapi_results = {
    "avg": 45,    # ms
    "p50": 38,    # ms
    "p99": 120    # ms
}

alpha_results = {
    "avg": 380,   # ms
    "p50": 320,   # ms
    "p99": 850    # ms
}

┌─────────────────────────────────────────────────────────────┐
│                  LATÊNCIA (ms) - BRASIL                     │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  brapi.dev                                                  │
│  ████░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░  45ms (avg)       │
│                                                             │
│  Alpha Vantage                                              │
│  ██████████████████████████████████░░░░░░  380ms (avg)      │
│                                                             │
│  Diferença: 8.4x mais rápido                                │
│                                                             │
└─────────────────────────────────────────────────────────────┘

# Python - Simples e direto
import requests

def get_quote(ticker):
    response = requests.get(
        f"https://brapi.dev/api/quote/{ticker}",
        headers={"Authorization": "Bearer TOKEN"}
    )
    return response.json()["results"][0]

# Múltiplas ações em uma requisição
quotes = requests.get(
    "https://brapi.dev/api/quote/PETR4,VALE3,ITUB4"
)

// TypeScript/Next.js - SDK oficial
import { brapi } from '@brapi/sdk';

const client = brapi({ token: 'TOKEN' });

// Type-safe
const quote = await client.quote('PETR4');
console.log(quote.regularMarketPrice); // TypeScript sabe o tipo

# Python - Mais verboso
import requests

def get_quote(ticker):
    response = requests.get(
        "https://www.alphavantage.co/query",
        params={
            "function": "GLOBAL_QUOTE",
            "symbol": f"{ticker}.SAO",  # Precisa adicionar .SAO
            "apikey": "API_KEY"
        }
    )
    data = response.json()
    # Estrutura de resposta aninhada
    return data.get("Global Quote", {})

# Apenas uma ação por requisição
# Para 10 ações = 10 requisições

# Estratégia híbrida
class FinanceAPI:
    def __init__(self):
        self.brapi_token = "BRAPI_TOKEN"
        self.alpha_key = "ALPHA_KEY"
    
    def get_brazilian_stock(self, ticker):
        """Usa brapi.dev para ações brasileiras"""
        return requests.get(
            f"https://brapi.dev/api/quote/{ticker}",
            headers={"Authorization": f"Bearer {self.brapi_token}"}
        ).json()
    
    def get_us_stock(self, ticker):
        """Usa Alpha Vantage para ações americanas"""
        return requests.get(
            "https://www.alphavantage.co/query",
            params={
                "function": "GLOBAL_QUOTE",
                "symbol": ticker,
                "apikey": self.alpha_key
            }
        ).json()
    
    def get_stock(self, ticker):
        """Roteamento automático"""
        if ticker.endswith(('3', '4', '11')):  # Padrão brasileiro
            return self.get_brazilian_stock(ticker)
        return self.get_us_stock(ticker)

# Antes (Alpha Vantage)
def get_price_alpha(ticker):
    response = requests.get(
        "https://www.alphavantage.co/query",
        params={
            "function": "GLOBAL_QUOTE",
            "symbol": f"{ticker}.SAO",
            "apikey": ALPHA_KEY
        }
    )
    data = response.json()
    quote = data.get("Global Quote", {})
    return float(quote.get("05. price", 0))

# Depois (brapi.dev)
def get_price_brapi(ticker):
    response = requests.get(
        f"https://brapi.dev/api/quote/{ticker}",
        headers={"Authorization": f"Bearer {BRAPI_TOKEN}"}
    )
    data = response.json()
    return data["results"][0]["regularMarketPrice"]

# Wrapper para migração gradual
class AlphaVantageCompat:
    """Wrapper que simula Alpha Vantage usando brapi.dev"""
    
    def __init__(self, brapi_token):
        self.token = brapi_token
        self.base_url = "https://brapi.dev/api"
    
    def query(self, function, symbol, **kwargs):
        """Simula a interface do Alpha Vantage"""
        # Remove .SAO se presente
        ticker = symbol.replace(".SAO", "")
        
        if function == "GLOBAL_QUOTE":
            return self._global_quote(ticker)
        elif function == "TIME_SERIES_DAILY":
            return self._time_series(ticker)
        elif function == "OVERVIEW":
            return self._overview(ticker)
        else:
            raise ValueError(f"Function {function} not supported")
    
    def _global_quote(self, ticker):
        resp = requests.get(
            f"{self.base_url}/quote/{ticker}",
            headers={"Authorization": f"Bearer {self.token}"}
        )
        data = resp.json()["results"][0]
        
        # Retorna no formato Alpha Vantage
        return {
            "Global Quote": {
                "01. symbol": data["symbol"],
                "05. price": str(data["regularMarketPrice"]),
                "09. change": str(data["regularMarketChange"]),
                "10. change percent": f"{data['regularMarketChangePercent']}%"
            }
        }

┌─────────────────────────────────────────────────────────────┐
│                 ESCOLHA SUA API                             │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  📊 Mercado Brasileiro (B3, FIIs, BDRs)                     │
│     → brapi.dev                                             │
│     ✓ Cobertura completa                                    │
│     ✓ Dados fundamentalistas                                │
│     ✓ Melhor preço                                          │
│     ✓ Suporte em português                                  │
│                                                             │
│  🌍 Mercados Internacionais                                 │
│     → Alpha Vantage                                         │
│     ✓ NYSE, NASDAQ, global                                  │
│     ✓ Forex                                                 │
│     ✓ Indicadores técnicos                                  │
│                                                             │
│  🔄 Estratégia Híbrida                                      │
│     → brapi.dev + Alpha Vantage                             │
│     ✓ Cobertura completa global                             │
│     ✓ Melhor de cada mundo                                  │
│                                                             │
└─────────────────────────────────────────────────────────────┘