Fundos Imobiliários (FIIs) 2026: Guia Completo para Iniciantes

┌─────────────────────────────────────────────────────────────┐
│                    ESTRUTURA DE UM FII                       │
├─────────────────────────────────────────────────────────────┤
│                                                              │
│   Investidores ──► Compram Cotas ──► Fundo Imobiliário      │
│        │                                    │                │
│        │                                    ▼                │
│        │                            Adquire Imóveis         │
│        │                                    │                │
│        │                                    ▼                │
│        │                            Aluga para Empresas     │
│        │                                    │                │
│        │                                    ▼                │
│        ◄────────────────────────── Distribui Rendimentos    │
│                                    (mínimo 95% do lucro)    │
│                                                              │
└─────────────────────────────────────────────────────────────┘

DY = (Dividendos 12 meses / Preço da Cota) × 100

Exemplo:
- Dividendos últimos 12 meses: R$ 12,00
- Preço atual da cota: R$ 100,00
- DY = (12 / 100) × 100 = 12% ao ano

P/VP = Preço da Cota / Valor Patrimonial por Cota

Interpretação:
- P/VP < 1,00 → Cota com "desconto" (pode ser oportunidade)
- P/VP = 1,00 → Cota pelo valor justo
- P/VP > 1,00 → Cota com "prêmio" (mercado otimista)

Vacância Física = (Área Vaga / Área Total) × 100
Vacância Financeira = (Receita Perdida / Receita Potencial) × 100

Referência:
- Vacância < 5% → Excelente
- Vacância 5-10% → Boa
- Vacância 10-20% → Atenção
- Vacância > 20% → Risco elevado

Cap Rate = (Receita Líquida Anual / Valor do Imóvel) × 100

Referência: Cap Rate saudável entre 7-10% ao ano

import requests
import pandas as pd

# Configuração da API brapi.dev
API_TOKEN = "seu_token_aqui"
BASE_URL = "https://brapi.dev/api"

def get_fii_data(ticker: str) -> dict:
    """
    Busca dados completos de um FII na brapi.dev
    """
    url = f"{BASE_URL}/quote/{ticker}"
    params = {
        "fundamental": "true",
        "dividends": "true"
    }
    headers = {"Authorization": f"Bearer {API_TOKEN}"}
    
    response = requests.get(url, params=params, headers=headers)
    response.raise_for_status()
    
    return response.json()["results"][0]

def analyze_fii(ticker: str) -> dict:
    """
    Analisa indicadores fundamentais de um FII
    """
    data = get_fii_data(ticker)
    
    # Extrai dados relevantes
    analysis = {
        "ticker": ticker,
        "nome": data.get("longName", "N/A"),
        "preco": data.get("regularMarketPrice", 0),
        "variacao_dia": data.get("regularMarketChangePercent", 0),
        "volume": data.get("regularMarketVolume", 0),
        "dividend_yield": data.get("dividendYield", 0),
        "p_vp": data.get("priceToBook", 0),
    }
    
    return analysis

# Analisa principais FIIs do mercado
fiis_populares = ["HGLG11", "XPLG11", "MXRF11", "KNCR11", "VISC11"]

print("=" * 60)
print("ANÁLISE DE FUNDOS IMOBILIÁRIOS")
print("=" * 60)

resultados = []
for fii in fiis_populares:
    try:
        analise = analyze_fii(fii)
        resultados.append(analise)
        
        print(f"\n📊 {analise['ticker']} - {analise['nome']}")
        print(f"   Preço: R$ {analise['preco']:.2f}")
        print(f"   Variação: {analise['variacao_dia']:.2f}%")
        print(f"   DY: {analise['dividend_yield']:.2f}%")
        print(f"   P/VP: {analise['p_vp']:.2f}")
        
    except Exception as e:
        print(f"Erro ao analisar {fii}: {e}")

# Cria DataFrame para comparação
df = pd.DataFrame(resultados)
print("\n" + "=" * 60)
print("TABELA COMPARATIVA")
print("=" * 60)
print(df.to_string(index=False))

def compare_fiis_by_segment():
    """
    Compara FIIs de diferentes segmentos
    """
    segments = {
        "Logístico": ["HGLG11", "XPLG11", "VILG11"],
        "Papel": ["KNCR11", "MXRF11", "CPTS11"],
        "Shopping": ["VISC11", "XPML11", "HSML11"],
        "Lajes": ["HGRE11", "BRCR11", "RCRB11"]
    }
    
    for segment, fiis in segments.items():
        print(f"\n{'='*50}")
        print(f"SEGMENTO: {segment.upper()}")
        print("="*50)
        
        segment_data = []
        for fii in fiis:
            try:
                data = analyze_fii(fii)
                segment_data.append(data)
            except:
                continue
        
        if segment_data:
            df = pd.DataFrame(segment_data)
            df = df.sort_values("dividend_yield", ascending=False)
            print(df[["ticker", "preco", "dividend_yield", "p_vp"]].to_string(index=False))

compare_fiis_by_segment()

def get_fii_dividends_history(ticker: str) -> pd.DataFrame:
    """
    Busca histórico de dividendos de um FII
    """
    url = f"{BASE_URL}/quote/{ticker}"
    params = {"dividends": "true"}
    headers = {"Authorization": f"Bearer {API_TOKEN}"}
    
    response = requests.get(url, params=params, headers=headers)
    data = response.json()["results"][0]
    
    dividends = data.get("dividendsData", {}).get("cashDividends", [])
    
    if not dividends:
        return pd.DataFrame()
    
    df = pd.DataFrame(dividends)
    df["paymentDate"] = pd.to_datetime(df["paymentDate"])
    df = df.sort_values("paymentDate", ascending=False)
    
    return df

def analyze_dividend_consistency(ticker: str):
    """
    Analisa consistência dos dividendos de um FII
    """
    df = get_fii_dividends_history(ticker)
    
    if df.empty:
        print(f"Sem dados de dividendos para {ticker}")
        return
    
    # Últimos 12 dividendos
    ultimos_12 = df.head(12)
    
    print(f"\n📈 ANÁLISE DE DIVIDENDOS - {ticker}")
    print("=" * 50)
    print(f"Total últimos 12 meses: R$ {ultimos_12['rate'].sum():.2f}")
    print(f"Média mensal: R$ {ultimos_12['rate'].mean():.2f}")
    print(f"Maior dividendo: R$ {ultimos_12['rate'].max():.2f}")
    print(f"Menor dividendo: R$ {ultimos_12['rate'].min():.2f}")
    print(f"Desvio padrão: R$ {ultimos_12['rate'].std():.2f}")
    
    # Coeficiente de variação (quanto menor, mais consistente)
    cv = (ultimos_12['rate'].std() / ultimos_12['rate'].mean()) * 100
    print(f"Coeficiente de variação: {cv:.1f}%")
    
    if cv < 10:
        print("✅ Dividendos muito consistentes")
    elif cv < 20:
        print("✓ Dividendos consistentes")
    elif cv < 30:
        print("⚠️ Dividendos moderadamente voláteis")
    else:
        print("❌ Dividendos muito voláteis")

# Analisa consistência de FIIs populares
for fii in ["MXRF11", "KNCR11", "HGLG11"]:
    analyze_dividend_consistency(fii)

┌─────────────────────────────────────────────────────────────┐
│              CHECKLIST DE ANÁLISE DE FIIs                   │
├─────────────────────────────────────────────────────────────┤
│                                                              │
│  ☐ 1. Liquidez adequada (volume diário > R$ 500k)           │
│  ☐ 2. DY competitivo vs. IFIX e Selic                       │
│  ☐ 3. P/VP próximo ou abaixo de 1,00                        │
│  ☐ 4. Vacância controlada (< 10%)                           │
│  ☐ 5. Contratos de longo prazo (típicos > 5 anos)           │
│  ☐ 6. Inquilinos diversificados e de qualidade              │
│  ☐ 7. Gestora com histórico comprovado                      │
│  ☐ 8. Taxa de administração razoável (< 1,5% a.a.)          │
│  ☐ 9. Imóveis bem localizados                               │
│  ☐ 10. Histórico de dividendos consistente                  │
│                                                              │
└─────────────────────────────────────────────────────────────┘

def build_income_portfolio():
    """
    Monta carteira focada em renda mensal
    """
    # FIIs com histórico de dividendos consistentes
    income_fiis = [
        {"ticker": "MXRF11", "peso": 20, "tipo": "Papel"},
        {"ticker": "KNCR11", "peso": 20, "tipo": "Papel"},
        {"ticker": "HGLG11", "peso": 15, "tipo": "Logístico"},
        {"ticker": "XPLG11", "peso": 15, "tipo": "Logístico"},
        {"ticker": "VISC11", "peso": 15, "tipo": "Shopping"},
        {"ticker": "HGRE11", "peso": 15, "tipo": "Lajes"},
    ]
    
    print("CARTEIRA DE RENDA MENSAL")
    print("=" * 50)
    
    total_dy = 0
    for fii in income_fiis:
        try:
            data = analyze_fii(fii["ticker"])
            dy = data.get("dividend_yield", 0)
            total_dy += dy * (fii["peso"] / 100)
            
            print(f"{fii['ticker']} ({fii['tipo']}): {fii['peso']}% | DY: {dy:.2f}%")
        except:
            print(f"{fii['ticker']}: Erro ao buscar dados")
    
    print("=" * 50)
    print(f"DY médio ponderado da carteira: {total_dy:.2f}%")
    
    # Simulação de renda
    capital = 100000
    renda_anual = capital * (total_dy / 100)
    renda_mensal = renda_anual / 12
    
    print(f"\nSimulação com R$ {capital:,.0f} investidos:")
    print(f"Renda anual estimada: R$ {renda_anual:,.2f}")
    print(f"Renda mensal estimada: R$ {renda_mensal:,.2f}")

build_income_portfolio()

def build_diversified_portfolio():
    """
    Monta carteira diversificada por segmentos
    """
    portfolio = {
        "Logístico": {"fiis": ["HGLG11", "XPLG11"], "peso": 25},
        "Papel": {"fiis": ["KNCR11", "MXRF11"], "peso": 25},
        "Shopping": {"fiis": ["VISC11", "XPML11"], "peso": 20},
        "Lajes": {"fiis": ["HGRE11", "BRCR11"], "peso": 15},
        "FOF": {"fiis": ["BCFF11"], "peso": 15}
    }
    
    print("CARTEIRA DIVERSIFICADA POR SEGMENTO")
    print("=" * 50)
    
    for segment, config in portfolio.items():
        print(f"\n{segment} ({config['peso']}% da carteira):")
        for fii in config["fiis"]:
            print(f"  - {fii}")

build_diversified_portfolio()

def simulate_fii_dca(
    ticker: str,
    aporte_mensal: float,
    meses: int
) -> dict:
    """
    Simula DCA em um FII
    """
    # Busca dados históricos
    url = f"{BASE_URL}/quote/{ticker}"
    params = {
        "range": "2y",
        "interval": "1mo"
    }
    headers = {"Authorization": f"Bearer {API_TOKEN}"}
    
    response = requests.get(url, params=params, headers=headers)
    data = response.json()["results"][0]
    historical = data.get("historicalDataPrice", [])
    
    if len(historical) < meses:
        meses = len(historical)
    
    total_investido = 0
    total_cotas = 0
    dividendos_acumulados = 0
    
    for i, month in enumerate(historical[-meses:]):
        preco = month["close"]
        cotas_compradas = aporte_mensal / preco
        
        total_investido += aporte_mensal
        total_cotas += cotas_compradas
        
        # Estima dividendos (simplificado)
        dy_mensal = 0.01  # ~1% ao mês
        dividendos = total_cotas * preco * dy_mensal
        dividendos_acumulados += dividendos
    
    preco_atual = historical[-1]["close"]
    valor_atual = total_cotas * preco_atual
    
    return {
        "ticker": ticker,
        "meses": meses,
        "total_investido": total_investido,
        "total_cotas": total_cotas,
        "preco_medio": total_investido / total_cotas,
        "valor_atual": valor_atual,
        "dividendos": dividendos_acumulados,
        "retorno_total": valor_atual + dividendos_acumulados - total_investido,
        "retorno_percentual": ((valor_atual + dividendos_acumulados) / total_investido - 1) * 100
    }

# Simula DCA em FII
resultado = simulate_fii_dca("HGLG11", 1000, 24)
print(f"\nSimulação DCA - {resultado['ticker']}")
print(f"Período: {resultado['meses']} meses")
print(f"Total investido: R$ {resultado['total_investido']:,.2f}")
print(f"Cotas acumuladas: {resultado['total_cotas']:.2f}")
print(f"Preço médio: R$ {resultado['preco_medio']:.2f}")
print(f"Valor atual: R$ {resultado['valor_atual']:,.2f}")
print(f"Dividendos recebidos: R$ {resultado['dividendos']:,.2f}")
print(f"Retorno total: {resultado['retorno_percentual']:.2f}%")

def compare_with_ifix(portfolio_fiis: list) -> None:
    """
    Compara carteira com o IFIX
    """
    # Busca dados do IFIX (representado por ETF ou índice)
    # Nota: Use dados reais do IFIX para comparação precisa
    
    print("COMPARATIVO COM IFIX")
    print("=" * 50)
    
    portfolio_dy = 0
    ifix_dy = 10.5  # DY médio histórico do IFIX
    
    for fii in portfolio_fiis:
        try:
            data = analyze_fii(fii["ticker"])
            portfolio_dy += data.get("dividend_yield", 0) * (fii["peso"] / 100)
        except:
            continue
    
    print(f"DY da sua carteira: {portfolio_dy:.2f}%")
    print(f"DY médio do IFIX: {ifix_dy:.2f}%")
    
    if portfolio_dy > ifix_dy:
        print(f"✅ Sua carteira supera o IFIX em {portfolio_dy - ifix_dy:.2f}%")
    else:
        print(f"⚠️ Sua carteira está {ifix_dy - portfolio_dy:.2f}% abaixo do IFIX")

def calculate_fii_tax(
    preco_compra: float,
    preco_venda: float,
    quantidade: int
) -> dict:
    """
    Calcula imposto sobre ganho de capital em FIIs
    """
    custo_total = preco_compra * quantidade
    valor_venda = preco_venda * quantidade
    lucro = valor_venda - custo_total
    
    if lucro <= 0:
        return {
            "lucro": lucro,
            "imposto": 0,
            "lucro_liquido": lucro,
            "mensagem": "Prejuízo - sem imposto, pode compensar em operações futuras"
        }
    
    imposto = lucro * 0.20  # 20% sobre o lucro
    
    return {
        "custo_total": custo_total,
        "valor_venda": valor_venda,
        "lucro_bruto": lucro,
        "aliquota": "20%",
        "imposto": imposto,
        "lucro_liquido": lucro - imposto,
        "darf_codigo": "6015"  # Código DARF para FIIs
    }

# Exemplo de cálculo
resultado = calculate_fii_tax(
    preco_compra=95.00,
    preco_venda=110.00,
    quantidade=100
)

print("CÁLCULO DE IR - GANHO DE CAPITAL FIIs")
print("=" * 50)
for key, value in resultado.items():
    if isinstance(value, float):
        print(f"{key}: R$ {value:.2f}")
    else:
        print(f"{key}: {value}")

import schedule
import time

def daily_fii_report():
    """
    Gera relatório diário dos seus FIIs
    """
    my_fiis = ["HGLG11", "MXRF11", "KNCR11", "VISC11"]
    
    print(f"\n{'='*60}")
    print(f"RELATÓRIO DIÁRIO DE FIIs - {pd.Timestamp.now().strftime('%d/%m/%Y')}")
    print("="*60)
    
    for fii in my_fiis:
        try:
            data = analyze_fii(fii)
            print(f"\n{data['ticker']}")
            print(f"  Preço: R$ {data['preco']:.2f}")
            print(f"  Variação: {data['variacao_dia']:+.2f}%")
            print(f"  DY: {data['dividend_yield']:.2f}%")
            
            # Alertas
            if data['variacao_dia'] < -3:
                print(f"  ⚠️ ALERTA: Queda expressiva!")
            if data['p_vp'] < 0.95:
                print(f"  💡 OPORTUNIDADE: P/VP abaixo de 0.95")
                
        except Exception as e:
            print(f"Erro ao analisar {fii}: {e}")

# Executa diariamente às 18h
schedule.every().day.at("18:00").do(daily_fii_report)

# Loop de execução (em produção)
# while True:
#     schedule.run_pending()
#     time.sleep(60)