Como Analisar a DRE (Demonstracao do Resultado do Exercicio) 2026: Guia Completo

O Que e a DRE e Por Que Você Precisa Entendê-la

A Demonstracao do Resultado do Exercicio (DRE) e o demonstrativo financeiro que revela se uma empresa está realmente ganhando dinheiro. Enquanto o balanco patrimonial mostra uma fotografia dos ativos e passivos em determinado momento, a DRE conta a historia de como a empresa gerou (ou perdeu) dinheiro durante um periodo.

Pense na DRE como o "filme" da operacao da empresa: ela mostra quanto entrou de receita, quanto saiu em custos e despesas, e quanto sobrou no final. É o demonstrativo que responde à pergunta mais importante: a empresa e lucrativa?

Por Que a DRE e Essencial para Investidores

A DRE revela informacões que nenhum outro demonstrativo oferece:

Informacao	O Que Revela	Por Que Importa
Receita Liquida	Capacidade de vender	Tamanho e crescimento do negocio
Lucro Bruto	Eficiência produtiva	Poder de precificacao
EBITDA	Geracao operacional de caixa	Capacidade de investir e pagar dividas
Lucro Liquido	Resultado final	Retorno real para acionistas
Margens	Eficiência em cada etapa	Vantagem competitiva sustentável

Estrutura Completa da DRE: Linha por Linha

A DRE segue uma estrutura logica que parte das vendas ate chegar ao lucro liquido. Vamos analisar cada componente:


                    ESTRUTURA DA DRE                         

                                                             
  (+) Receita Bruta de Vendas                                
  (-) Deducões (impostos, devolucões, abatimentos)           
  ════════════════════════════════════════════════           
  (=) RECEITA LÍQUIDA                                        
                                                             
  (-) Custo dos Produtos/Servicos Vendidos (CPV/CSV)         
  ════════════════════════════════════════════════           
  (=) LUCRO BRUTO                                            
                                                             
  (-) Despesas Operacionais                                  
      • Vendas e Marketing                                   
      • Gerais e Administrativas                             
      • Pesquisa e Desenvolvimento                           
  (+) Outras Receitas Operacionais                           
  ════════════════════════════════════════════════           
  (=) EBIT (Lucro Operacional)                               
                                                             
  (+) Receitas Financeiras                                   
  (-) Despesas Financeiras                                   
  ════════════════════════════════════════════════           
  (=) LUCRO ANTES DO IR (EBT)                                
                                                             
  (-) Imposto de Renda e CSLL                                
  ════════════════════════════════════════════════           
  (=) LUCRO LÍQUIDO

1. Receita Bruta vs Receita Liquida

A Receita Bruta e o valor total das vendas antes de qualquer deducao. Já a Receita Liquida e o que efetivamente entra no caixa apos:

Impostos sobre vendas: ICMS, PIS, COFINS, ISS
Devolucões: Produtos retornados por clientes
Abatimentos: Descontos concedidos

import requests

def analisar_receita_empresa(ticker: str) -> dict:
    """
    Analisa a evolucao da receita de uma empresa usando brapi.dev
    """
    url = f"https://brapi.dev/api/quote/{ticker}"
    params = {
        "modules": "incomeStatementHistory",
        "fundamental": "true"
    }
    headers = {"Authorization": "Bearer SEU_TOKEN_AQUI"}
    
    response = requests.get(url, params=params, headers=headers)
    data = response.json()
    
    if "results" not in data or len(data["results"]) == 0:
        return {"erro": "Dados nao encontrados"}
    
    resultado = data["results"][0]
    
    # Extrair dados de receita do income statement
    income_statements = resultado.get("incomeStatementHistory", {}).get("incomeStatementHistory", [])
    
    analise = {
        "ticker": ticker,
        "nome": resultado.get("longName", ""),
        "evolucao_receita": []
    }
    
    for statement in income_statements:
        ano = statement.get("endDate", {}).get("fmt", "N/A")
        receita_total = statement.get("totalRevenue", {}).get("raw", 0)
        lucro_bruto = statement.get("grossProfit", {}).get("raw", 0)
        lucro_liquido = statement.get("netIncome", {}).get("raw", 0)
        
        # Calcular margens
        margem_bruta = (lucro_bruto / receita_total * 100) if receita_total > 0 else 0
        margem_liquida = (lucro_liquido / receita_total * 100) if receita_total > 0 else 0
        
        analise["evolucao_receita"].append({
            "periodo": ano,
            "receita_milhoes": receita_total / 1_000_000,
            "lucro_bruto_milhoes": lucro_bruto / 1_000_000,
            "lucro_liquido_milhoes": lucro_liquido / 1_000_000,
            "margem_bruta": round(margem_bruta, 2),
            "margem_liquida": round(margem_liquida, 2)
        })
    
    return analise

resultado = analisar_receita_empresa("WEGE3")
print(f"\n📊 Análise de Receita: {resultado['nome']}")
for periodo in resultado["evolucao_receita"]:
    print(f"\n{periodo['periodo']}:")
    print(f"  Receita: R$ {periodo['receita_milhoes']:,.0f} milhões")
    print(f"  Margem Bruta: {periodo['margem_bruta']}%")
    print(f"  Margem Liquida: {periodo['margem_liquida']}%")

2. Custo dos Produtos/Servicos Vendidos (CPV/CSV)

O CPV representa todos os custos diretamente ligados à producao ou prestacao de servicos:

Tipo de Empresa	Componentes do CPV
Indústria	Materia-prima, mao de obra direta, energia da fábrica, depreciacao de máquinas
Varejo	Custo de aquisicao das mercadorias
Servicos	Mao de obra direta, materiais usados no servico
Software	Custos de hospedagem, suporte tecnico direto

3. Lucro Bruto e Margem Bruta

O Lucro Bruto e a diferenca entre Receita Liquida e CPV. A Margem Bruta mostra quanto sobra de cada real vendido apos cobrir os custos diretos:

Margem Bruta = (Lucro Bruto / Receita Liquida) × 100

Interpretacao da Margem Bruta por Setor:

Setor	Margem Bruta Tipica	Exemplo
Software/SaaS	70-90%	TOTS3: ~55%
Farmacêutico	60-80%	RADL3: ~28%
Bens de Capital	25-40%	WEGE3: ~33%
Varejo	20-35%	MGLU3: ~25%
Commodities	15-30%	VALE3: ~40%
Supermercados	20-25%	CRFB3: ~21%

Insight importante: Margens brutas altas indicam poder de precificacao e/ou eficiência produtiva. Empresas com margens brutas consistentemente acima dos concorrentes geralmente têm vantagens competitivas.

4. Despesas Operacionais

As despesas operacionais sao custos necessários para manter a empresa funcionando, mas nao diretamente ligados à producao:

Despesas com Vendas:

Comissões de vendedores
Marketing e publicidade
Logistica de distribuicao
Pos-venda e garantia

Despesas Gerais e Administrativas (G&A):

Salários administrativos
Aluguel de escritorios
Sistemas e TI
Servicos profissionais (contabilidade, juridico)

Pesquisa e Desenvolvimento (P&D):

Salários de engenheiros e pesquisadores
Testes e prototipos
Patentes e propriedade intelectual

5. EBIT e EBITDA

O EBIT (Earnings Before Interest and Taxes) e o lucro operacional, antes de juros e impostos. Mostra quanto a empresa gera apenas com sua operacao principal.

O EBITDA adiciona de volta depreciacao e amortizacao, mostrando a geracao de caixa operacional:

EBITDA = EBIT + Depreciacao + Amortizacao

def calcular_ebitda_margem(ticker: str) -> dict:
    """
    Calcula EBITDA e margem EBITDA usando dados da brapi.dev
    """
    url = f"https://brapi.dev/api/quote/{ticker}"
    params = {"fundamental": "true"}
    headers = {"Authorization": "Bearer SEU_TOKEN_AQUI"}
    
    response = requests.get(url, params=params, headers=headers)
    data = response.json()
    
    if "results" not in data:
        return {"erro": "Dados nao encontrados"}
    
    resultado = data["results"][0]
    
    # Dados fundamentalistas
    ebitda = resultado.get("ebitda", 0)
    receita = resultado.get("totalRevenue", 0)
    margem_ebitda = resultado.get("ebitdaMargins", 0)
    
    return {
        "ticker": ticker,
        "nome": resultado.get("longName", ""),
        "ebitda_bilhoes": ebitda / 1_000_000_000 if ebitda else 0,
        "receita_bilhoes": receita / 1_000_000_000 if receita else 0,
        "margem_ebitda_pct": margem_ebitda * 100 if margem_ebitda else 0
    }

empresas = ["WEGE3", "VALE3", "ITUB4", "MGLU3", "PETR4"]

print("📊 Comparativo de Margens EBITDA\n")
print(f"{'Ticker':<10} {'Empresa':<30} {'EBITDA (Bi)':<15} {'Margem EBITDA':<15}")
print("-" * 70)

for ticker in empresas:
    dados = calcular_ebitda_margem(ticker)
    print(f"{dados['ticker']:<10} {dados['nome'][:28]:<30} R$ {dados['ebitda_bilhoes']:>8.1f} {dados['margem_ebitda_pct']:>10.1f}%")

6. Resultado Financeiro

O resultado financeiro mostra o impacto das decisões de financiamento:

Receitas Financeiras:

Rendimentos de aplicacões
Juros recebidos
Variacao cambial positiva

Despesas Financeiras:

Juros sobre emprestimos
Variacao cambial negativa
Custos de hedge

Atencao: Empresas muito endividadas podem ter lucro operacional positivo mas prejuizo liquido devido às despesas financeiras. Sempre analise o endividamento junto com a DRE.

7. Lucro Liquido e Margem Liquida

O Lucro Liquido e o resultado final apos todos os custos, despesas, juros e impostos. É o que efetivamente pertence aos acionistas.

Margem Liquida = (Lucro Liquido / Receita Liquida) × 100

Benchmarks de Margem Liquida:

Classificacao	Margem Liquida	Interpretacao
Excepcional	> 20%	Vantagem competitiva forte
Boa	10-20%	Empresa eficiente
Media	5-10%	Normal para maioria dos setores
Baixa	2-5%	Negocio commoditizado
Muito baixa	menor que 2%	Risco operacional alto

Análise Vertical e Horizontal da DRE

Análise Vertical

A análise vertical expressa cada linha da DRE como percentual da Receita Liquida:

def analise_vertical_dre(ticker: str) -> dict:
    """
    Realiza análise vertical da DRE
    """
    url = f"https://brapi.dev/api/quote/{ticker}"
    params = {
        "modules": "incomeStatementHistory",
        "fundamental": "true"
    }
    headers = {"Authorization": "Bearer SEU_TOKEN_AQUI"}
    
    response = requests.get(url, params=params, headers=headers)
    data = response.json()
    
    if "results" not in data:
        return {"erro": "Dados nao encontrados"}
    
    resultado = data["results"][0]
    statements = resultado.get("incomeStatementHistory", {}).get("incomeStatementHistory", [])
    
    if not statements:
        return {"erro": "Sem dados historicos"}
    
    # Pegar o periodo mais recente
    ultimo = statements[0]
    receita = ultimo.get("totalRevenue", {}).get("raw", 1)  # Evitar divisao por zero
    
    analise = {
        "ticker": ticker,
        "periodo": ultimo.get("endDate", {}).get("fmt", "N/A"),
        "estrutura_vertical": {
            "receita_liquida": 100.0,
            "custo_receita": round(ultimo.get("costOfRevenue", {}).get("raw", 0) / receita * 100, 1),
            "lucro_bruto": round(ultimo.get("grossProfit", {}).get("raw", 0) / receita * 100, 1),
            "despesas_operacionais": round(ultimo.get("totalOperatingExpenses", {}).get("raw", 0) / receita * 100, 1),
            "ebit": round(ultimo.get("ebit", {}).get("raw", 0) / receita * 100, 1),
            "lucro_antes_ir": round(ultimo.get("incomeBeforeTax", {}).get("raw", 0) / receita * 100, 1),
            "lucro_liquido": round(ultimo.get("netIncome", {}).get("raw", 0) / receita * 100, 1)
        }
    }
    
    return analise

# Exemplo
resultado = analise_vertical_dre("WEGE3")
print(f"\n📊 Análise Vertical - {resultado['ticker']} ({resultado['periodo']})\n")
for linha, valor in resultado["estrutura_vertical"].items():
    barra = "█" * int(abs(valor) / 2)
    print(f"{linha.replace('_', ' ').title():<25} {valor:>6.1f}% {barra}")

Análise Horizontal

A análise horizontal compara a evolucao das linhas ao longo do tempo:

def analise_horizontal_dre(ticker: str) -> dict:
    """
    Realiza análise horizontal da DRE (crescimento ano a ano)
    """
    url = f"https://brapi.dev/api/quote/{ticker}"
    params = {
        "modules": "incomeStatementHistory",
        "fundamental": "true"
    }
    headers = {"Authorization": "Bearer SEU_TOKEN_AQUI"}
    
    response = requests.get(url, params=params, headers=headers)
    data = response.json()
    
    if "results" not in data:
        return {"erro": "Dados nao encontrados"}
    
    resultado = data["results"][0]
    statements = resultado.get("incomeStatementHistory", {}).get("incomeStatementHistory", [])
    
    if len(statements) < 2:
        return {"erro": "Dados insuficientes para análise horizontal"}
    
    # Comparar últimos dois periodos
    atual = statements[0]
    anterior = statements[1]
    
    def crescimento(atual_val, anterior_val):
        if anterior_val and anterior_val != 0:
            return round((atual_val - anterior_val) / abs(anterior_val) * 100, 1)
        return 0
    
    analise = {
        "ticker": ticker,
        "periodo_atual": atual.get("endDate", {}).get("fmt", "N/A"),
        "periodo_anterior": anterior.get("endDate", {}).get("fmt", "N/A"),
        "crescimento_yoy": {
            "receita": crescimento(
                atual.get("totalRevenue", {}).get("raw", 0),
                anterior.get("totalRevenue", {}).get("raw", 0)
            ),
            "lucro_bruto": crescimento(
                atual.get("grossProfit", {}).get("raw", 0),
                anterior.get("grossProfit", {}).get("raw", 0)
            ),
            "ebit": crescimento(
                atual.get("ebit", {}).get("raw", 0),
                anterior.get("ebit", {}).get("raw", 0)
            ),
            "lucro_liquido": crescimento(
                atual.get("netIncome", {}).get("raw", 0),
                anterior.get("netIncome", {}).get("raw", 0)
            )
        }
    }
    
    return analise

# Exemplo
resultado = analise_horizontal_dre("WEGE3")
print(f"\n📈 Análise Horizontal - {resultado['ticker']}")
print(f"Comparando: {resultado['periodo_anterior']} → {resultado['periodo_atual']}\n")

for metrica, crescimento in resultado["crescimento_yoy"].items():
    sinal = "+" if crescimento > 0 else ""
    emoji = "🟢" if crescimento > 0 else "🔴" if crescimento < 0 else "⚪"
    print(f"{emoji} {metrica.replace('_', ' ').title():<20} {sinal}{crescimento}%")

Red Flags na DRE: Sinais de Alerta

Ao analisar a DRE, fique atento a estes sinais de alerta:

1. Receita Crescendo, Lucro Caindo

# 
#  🚨 RED FLAG: Compressao de Margens              
# 
#                                                  
#  Receita:  ████████████████████████  +15%        
#  Lucro:    ████████████              -8%         
#                                                  
#  Possiveis causas:                               
#  • Aumento de custos nao repassado               
#  • Guerra de precos com concorrentes             
#  • Perda de eficiência operacional               
#  • Aquisicões mal integradas                     
#                                                  
#

2. Despesas Financeiras Crescentes

Quando as despesas financeiras crescem mais rápido que o EBIT, a empresa está se alavancando demais.

3. Lucro Liquido Muito Diferente do Lucro Operacional

Quando o lucro liquido e muito maior ou menor que o EBIT, investigue:

Situacao	Possivel Causa	Acao
LL maior maior que EBIT	Ganhos nao recorrentes, venda de ativos	Desconsiderar para projecões
LL menor menor que EBIT	Despesas financeiras altas, IR alto	Verificar endividamento
LL negativo, EBIT positivo	Divida excessiva	Avaliar capacidade de desalavancagem

4. Margem Bruta em Queda Consistente

def analisar_tendencia_margens(ticker: str) -> dict:
    """
    Analisa tendência das margens ao longo dos anos
    """
    url = f"https://brapi.dev/api/quote/{ticker}"
    params = {
        "modules": "incomeStatementHistory",
        "fundamental": "true"
    }
    headers = {"Authorization": "Bearer SEU_TOKEN_AQUI"}
    
    response = requests.get(url, params=params, headers=headers)
    data = response.json()
    
    if "results" not in data:
        return {"erro": "Dados nao encontrados"}
    
    resultado = data["results"][0]
    statements = resultado.get("incomeStatementHistory", {}).get("incomeStatementHistory", [])
    
    margens = []
    for stmt in statements:
        receita = stmt.get("totalRevenue", {}).get("raw", 0)
        lucro_bruto = stmt.get("grossProfit", {}).get("raw", 0)
        lucro_liquido = stmt.get("netIncome", {}).get("raw", 0)
        
        if receita > 0:
            margens.append({
                "periodo": stmt.get("endDate", {}).get("fmt", "N/A"),
                "margem_bruta": round(lucro_bruto / receita * 100, 1),
                "margem_liquida": round(lucro_liquido / receita * 100, 1)
            })
    
    # Verificar tendência
    if len(margens) >= 2:
        tendencia_bruta = margens[0]["margem_bruta"] - margens[-1]["margem_bruta"]
        tendencia_liquida = margens[0]["margem_liquida"] - margens[-1]["margem_liquida"]
    else:
        tendencia_bruta = 0
        tendencia_liquida = 0
    
    return {
        "ticker": ticker,
        "historico": margens,
        "tendencia_margem_bruta": round(tendencia_bruta, 1),
        "tendencia_margem_liquida": round(tendencia_liquida, 1),
        "alerta": tendencia_bruta < -5 or tendencia_liquida < -5
    }

Comparando DREs de Empresas do Mesmo Setor

A análise comparativa e fundamental para identificar quais empresas sao mais eficientes:

def comparar_dre_setor(tickers: list) -> list:
    """
    Compara DRE de múltiplas empresas do mesmo setor
    """
    comparativo = []
    
    for ticker in tickers:
        url = f"https://brapi.dev/api/quote/{ticker}"
        params = {"fundamental": "true"}
        headers = {"Authorization": "Bearer SEU_TOKEN_AQUI"}
        
        response = requests.get(url, params=params, headers=headers)
        data = response.json()
        
        if "results" not in data or len(data["results"]) == 0:
            continue
        
        r = data["results"][0]
        
        comparativo.append({
            "ticker": ticker,
            "nome": r.get("shortName", ""),
            "receita_bi": r.get("totalRevenue", 0) / 1_000_000_000,
            "margem_bruta": r.get("grossMargins", 0) * 100 if r.get("grossMargins") else 0,
            "margem_ebitda": r.get("ebitdaMargins", 0) * 100 if r.get("ebitdaMargins") else 0,
            "margem_liquida": r.get("profitMargins", 0) * 100 if r.get("profitMargins") else 0,
            "roe": r.get("returnOnEquity", 0) * 100 if r.get("returnOnEquity") else 0
        })
    
    # Ordenar por margem EBITDA
    comparativo.sort(key=lambda x: x["margem_ebitda"], reverse=True)
    
    return comparativo

# Comparar bancos
bancos = ["ITUB4", "BBDC4", "BBAS3", "SANB11"]
resultado = comparar_dre_setor(bancos)

print("\n📊 Comparativo de Margens - Setor Bancário\n")
print(f"{'Ticker':<10} {'Margem Bruta':<15} {'Margem EBITDA':<15} {'Margem Liquida':<15} {'ROE':<10}")
print("-" * 65)

for empresa in resultado:
    print(f"{empresa['ticker']:<10} {empresa['margem_bruta']:>10.1f}% {empresa['margem_ebitda']:>12.1f}% {empresa['margem_liquida']:>13.1f}% {empresa['roe']:>8.1f}%")

Case Study: Análise da DRE da WEG (WEGE3)

Vamos fazer uma análise completa da DRE da WEG, uma das empresas mais admiradas da B3:

def case_study_weg():
    """
    Análise completa da DRE da WEG
    """
    url = "https://brapi.dev/api/quote/WEGE3"
    params = {
        "modules": "incomeStatementHistory",
        "fundamental": "true"
    }
    headers = {"Authorization": "Bearer SEU_TOKEN_AQUI"}
    
    response = requests.get(url, params=params, headers=headers)
    data = response.json()
    
    if "results" not in data:
        return
    
    r = data["results"][0]
    
    print("=" * 60)
    print("CASE STUDY: WEG S.A. (WEGE3)")
    print("=" * 60)
    print(f"\nSetor: Bens de Capital / Equipamentos Eletricos")
    print(f"Preco atual: R$ {r.get('regularMarketPrice', 0):.2f}")
    print(f"Market Cap: R$ {r.get('marketCap', 0) / 1_000_000_000:.1f} bilhões")
    
    print("\n📊 MÉTRICAS DE LUCRATIVIDADE")
    print("-" * 40)
    print(f"Receita (12m): R$ {r.get('totalRevenue', 0) / 1_000_000_000:.1f} bilhões")
    print(f"EBITDA: R$ {r.get('ebitda', 0) / 1_000_000_000:.1f} bilhões")
    print(f"Lucro Liquido: R$ {r.get('netIncomeToCommon', 0) / 1_000_000_000:.1f} bilhões")
    
    print("\n📈 MARGENS")
    print("-" * 40)
    print(f"Margem Bruta: {r.get('grossMargins', 0) * 100:.1f}%")
    print(f"Margem EBITDA: {r.get('ebitdaMargins', 0) * 100:.1f}%")
    print(f"Margem Liquida: {r.get('profitMargins', 0) * 100:.1f}%")
    
    print("\n🎯 EFICIÊNCIA")
    print("-" * 40)
    print(f"ROE: {r.get('returnOnEquity', 0) * 100:.1f}%")
    print(f"ROA: {r.get('returnOnAssets', 0) * 100:.1f}%")
    
    print("\n💡 ANÁLISE")
    print("-" * 40)
    print("""
A WEG demonstra caracteristicas tipicas de uma empresa de qualidade:
    
✓ Margens consistentes ao longo dos anos
✓ ROE elevado (acima de 20%)
✓ Crescimento de receita sustentável
✓ Baixo endividamento
✓ Diversificacao geográfica (mais de 50% internacional)
    
Pontos de atencao:
• Múltiplo P/L elevado (30x+)
• Exposicao cambial significativa
• Ciclo de commodities afeta custos
""")

case_study_weg()

DRE Trimestral vs Anual: Quando Usar Cada Uma

Aspecto	DRE Trimestral	DRE Anual
Sazonalidade	Revela padrões sazonais	Normaliza efeitos sazonais
Tendências	Identifica mudancas recentes	Mostra tendência de longo prazo
Comparacao	Compare com mesmo trimestre do ano anterior	Compare anos consecutivos
Eventos nao recorrentes	Pode distorcer análise	Diluidos no periodo maior

Ajustando para Sazonalidade

def analisar_sazonalidade(ticker: str) -> dict:
    """
    Identifica padrões sazonais na receita
    Requer dados trimestrais historicos
    """
    url = f"https://brapi.dev/api/quote/{ticker}"
    params = {
        "modules": "incomeStatementHistoryQuarterly",
        "fundamental": "true"
    }
    headers = {"Authorization": "Bearer SEU_TOKEN_AQUI"}
    
    response = requests.get(url, params=params, headers=headers)
    data = response.json()
    
    # Análise simplificada - em producao, agrupar por trimestre
    return {
        "ticker": ticker,
        "nota": "Empresas de varejo tipicamente têm Q4 mais forte (Black Friday, Natal)",
        "recomendacao": "Compare sempre trimestres equivalentes (YoY)"
    }

Integrando DRE com Outros Demonstrativos

A DRE ganha ainda mais poder quando analisada junto com outros demonstrativos:


                  ANÁLISE INTEGRADA                          

                                                             
  DRE                    Balanco                 DFC         
                                                
  Lucro Liquido ► Patrimônio ◄ Caixa Gerado    
                                                          
                                                          
       ▼                     ▼                    ▼          
     ROE = LL / PL      Alavancagem       FCO vs LL         
                                                             
  Se FCO menor que LL consistentemente → Qualidade do lucro baixa    
  Se ROE > 20% com baixa alavancagem → Empresa de qualidade

Conclusao: Checklist de Análise da DRE

Ao analisar qualquer DRE, siga este checklist:

Checklist de Análise da DRE

Crescimento de Receita: Está acima da inflacao? Acima do setor?
Margem Bruta: Estável ou crescendo? Acima dos concorrentes?
Margem EBITDA: Demonstra eficiência operacional?
Resultado Financeiro: Despesas financeiras sao sustentáveis?
Margem Liquida: Compativel com o setor?
Tendência: Margens estao melhorando ou piorando?
Qualidade: Lucro e recorrente ou há itens extraordinários?
Consistência: Resultados sao previsiveis?

Proximos Passos

Agora que você domina a DRE, complete sua análise fundamentalista:

Como Ler o Balanco Patrimonial - Entenda a saúde financeira
Guia de EBIT e EBITDA - Aprofunde na geracao de caixa
EV/EBITDA - Use a DRE para valuation
Fluxo de Caixa Descontado - Projete resultados futuros

Automatize Sua Análise com brapi.dev

A API da brapi.dev oferece acesso completo aos dados da DRE de todas as empresas listadas na B3. Com uma única chamada, você obtem:

Historico de demonstrativos anuais e trimestrais
Todas as linhas da DRE
Margens pre-calculadas
Dados atualizados automaticamente

Comece gratuitamente em brapi.dev e automatize suas análises de DRE com Python, JavaScript ou qualquer linguagem de sua preferência.