Melhores ações de dividendos em 2026: como montar seu ranking com dados reais

Por que não confiar numa lista pronta

Pesquise "melhores ações de dividendos 2026" e você encontrará dezenas de listas com tickers e percentuais fixos. O problema é estrutural, não de má vontade de quem escreve: o dividend yield (DY) é uma fração cujo denominador é o preço da ação, e o preço muda todo pregão. Uma lista publicada em janeiro pode estar completamente defasada em julho.

Há um segundo problema, mais perigoso. DY alto raramente significa "empresa generosa". Na maioria dos casos, significa que o preço caiu — e o preço às vezes cai porque o mercado antecipa que os proventos futuros vão encolher. É a clássica armadilha de dividendos (dividend trap): você compra atraído por um yield de dois dígitos e, no ano seguinte, a empresa corta o pagamento.

A alternativa robusta é não confiar em nenhuma lista estática — inclusive esta. Em vez disso, você define critérios uma vez e deixa a API gerar o ranking do dia. É exatamente isso que vamos construir aqui, passo a passo, usando dados oficiais de B3, CVM e BCB agregados pela bolsai.

A metodologia em quatro filtros

Um bom ranking de dividendos não ordena apenas por DY. Ele parte do yield, mas filtra por qualidade. Vamos usar quatro camadas, todas cobertas por campos que a API expõe:

1. 1. Yield relevante — o campo dividend_yield (TTM, últimos 12 meses) em /fundamentals. É o ponto de partida, nunca a decisão final.
2. 2. Payout sustentável — a empresa distribui uma fatia razoável do lucro? Calculamos combinando os proventos do endpoint /dividends com o lpa (lucro por ação) de /fundamentals.
3. 3. Consistência — ela paga há vários anos, ou foi um pico isolado? O histórico vem de /dividends?years=N.
4. 4. Endividamento sob controle — dívida alta compromete dividendos futuros. Usamos net_debt_ebitda.

Nas próximas seções, cada filtro vira código. No fim, você terá uma função que recebe uma lista de candidatas e devolve um ranking classificado — o seu, gerado com os números de hoje.

Setup: chave gratuita e primeira chamada

Crie uma conta gratuita com login Google e copie sua chave no dashboard. O plano gratuito dá 200 requisições por dia, mais que suficiente para montar e testar o ranking. Não existe SDK para instalar: a API é REST pura, então usamos a biblioteca requests.

pip install requests

A autenticação aceita a chave via parâmetro api_key ou pelo header Authorization: Bearer. Vamos definir as constantes usadas em todos os exemplos:

import requests

API_KEY = "sua_chave_aqui"
BASE = "https://api.usebolsai.com/api/v1"

# A chave pode ir no parâmetro api_key (usado abaixo) ou no header:
# headers = {"Authorization": f"Bearer {API_KEY}"}

Antes de tudo, uma chamada mínima e 100% executável — o exemplo canônico para conferir que sua chave funciona. Ele lê os fundamentos de uma ação e imprime o P/L, o P/VP e o dividend yield:

import requests

BASE = "https://api.usebolsai.com/api/v1"
r = requests.get(f"{BASE}/fundamentals/TAEE11", params={"api_key": "sua_chave_aqui"})
d = r.json()
print(d["pl"], d["pvp"], d["dividend_yield"])

Se retornar três números, está tudo certo. Repare que dividend_yield vem pronto: a bolsai já soma os proventos dos últimos 12 meses e divide pelo preço de fechamento mais recente. Não precisamos recalcular o DY na mão — mas precisamos, sim, dos outros três filtros.

Filtro 1: gerar a lista bruta com o screener

Aqui está a peça central deste guia e a razão de ele não trazer uma tabela decorada. Em vez de eu listar tickers, você chama o screener e recebe o ranking real do dia. O endpoint GET /api/v1/screener aceita operadores (_gt, _gte, _lt, _lte, _eq) sobre qualquer campo de fundamentos, além de sector, sort, order e limit.

Para começar amplo — todas as ações da B3 com DY acima de 8%, ordenadas do maior para o menor:

# A query que gera o ranking de hoje (não uma lista estática)
# GET /screener?dividend_yield_gt=8&sort=dividend_yield&order=desc&limit=20

import requests

BASE = "https://api.usebolsai.com/api/v1"
API_KEY = "sua_chave_aqui"

r = requests.get(
    f"{BASE}/screener",
    params={
        "api_key": API_KEY,
        "dividend_yield_gt": 8,
        "sort": "dividend_yield",
        "order": "desc",
        "limit": 20,
    },
)
resultado = r.json()
for acao in resultado:
    print(acao["ticker"], acao["dividend_yield"])

Esse dividend_yield_gt=8 é o coração da abordagem: o corte de 8% é uma escolha sua, não uma verdade absoluta. Se o CDI estiver mais baixo, talvez 6% já seja atraente; se estiver alto, você pode exigir mais. O ponto é que você controla o critério e a API devolve os papéis que o satisfazem hoje.

Refinando por setor e qualidade na própria query

O screener aceita vários filtros combinados, o que já elimina grande parte do trabalho manual. Você pode, por exemplo, pedir só bancos com DY acima de 6%, ROE acima de 10% e P/L abaixo de 15:

# GET /screener?sector=Bancos÷nd_yield_gt=6&roe_gt=10&pl_lt=15
#            &sort=dividend_yield&order=desc&limit=20

r = requests.get(
    f"{BASE}/screener",
    params={
        "api_key": API_KEY,
        "sector": "Bancos",
        "dividend_yield_gt": 6,
        "roe_gt": 10,
        "pl_lt": 15,
        "sort": "dividend_yield",
        "order": "desc",
        "limit": 20,
    },
)

O parâmetro sector usa os nomes de setor da CVM em português (como Bancos, Energia Elétrica, Saneamento). Não invente nomes: descubra os valores válidos pelo endpoint GET /api/v1/companies/sectors, que lista todos os setores e subsetores disponíveis. Assim você tem certeza de que o filtro corresponde à taxonomia real do banco de dados.

Filtro 2: payout, para separar generosidade de insustentabilidade

Uma empresa que distribui 130% do lucro está pagando com caixa que não gerou — algo que não se sustenta. O payout mede essa fatia. A API não entrega um campo payout pronto, e isso é bom: você monta a métrica com transparência total, combinando dois endpoints.

A ideia: somar os proventos por ação dos últimos 12 meses (endpoint /dividends) e dividir pelo lpa (lucro por ação, de /fundamentals). Antes, vale entender o formato do endpoint de dividendos. Ele aceita o parâmetro years e devolve uma lista de pagamentos, cada um com quatro campos: ex_date (data-com), payment_date (data de pagamento), value (valor por ação) e type (que pode ser DIVIDEND, JCP ou BONIFICACAO).

# Proventos dos últimos 5 anos de uma ação
r = requests.get(
    f"{BASE}/dividends/BBSE3",
    params={"api_key": API_KEY, "years": 5},
)
pagamentos = r.json()

for p in pagamentos[:3]:
    print(p["ex_date"], p["type"], p["value"])

A resposta terá o formato abaixo. Os números são ilustrativos (placeholders para mostrar a estrutura), não a cotação real de nenhuma data — para ver os valores atuais, rode o código com sua chave:

Um detalhe que separa o cálculo amador do correto: JCP também é provento. Muita gente soma só o tipo DIVIDEND e subestima o retorno de bancos e seguradoras, que pagam bastante via juros sobre capital próprio. Já BONIFICACAO é bonificação em ações, não dinheiro — normalmente fica de fora do cálculo de renda. Com isso claro, montamos o payout:

from datetime import date, timedelta

def proventos_ttm(ticker: str) -> float:
    """Soma dividendos e JCP em dinheiro dos últimos 365 dias."""
    r = requests.get(
        f"{BASE}/dividends/{ticker}",
        params={"api_key": API_KEY, "years": 2},
    )
    corte = date.today() - timedelta(days=365)
    total = 0.0
    for p in r.json():
        if p["type"] in ("DIVIDEND", "JCP"):
            if date.fromisoformat(p["ex_date"]) >= corte:
                total += p["value"]
    return total


def payout(ticker: str):
    """payout = proventos por ação (TTM) / LPA."""
    fund = requests.get(
        f"{BASE}/fundamentals/{ticker}",
        params={"api_key": API_KEY},
    ).json()
    lpa = fund.get("lpa")
    if not lpa or lpa <= 0:
        return None  # lucro nulo/negativo: payout não faz sentido
    return round(proventos_ttm(ticker) / lpa * 100, 1)


print(payout("BBSE3"))

Como interpretar? Um payout entre 40% e 80% costuma indicar equilíbrio entre distribuir e reinvestir. Acima de 100% é bandeira vermelha: a empresa está pagando mais do que lucrou (às vezes por um evento não recorrente, às vezes por distribuição de reservas). Setores regulados e maduros, como transmissão de energia, às vezes sustentam payouts altos por terem pouca necessidade de reinvestir — por isso o payout é lido junto com o setor, nunca isolado.

Filtro 3: consistência ao longo dos anos

Um DY de 12% num único ano pode ter vindo de um dividendo extraordinário — venda de ativo, mudança de política — que não se repete. O que interessa para renda passiva é a recorrência. Com o parâmetro years do endpoint /dividends, dá para agrupar os pagamentos por ano e ver quantos anos seguidos a empresa distribuiu:

from collections import defaultdict

def anos_pagando(ticker: str, minimo_por_ano: float = 0.01) -> int:
    """Conta anos consecutivos com proventos em dinheiro (do mais recente)."""
    r = requests.get(
        f"{BASE}/dividends/{ticker}",
        params={"api_key": API_KEY, "years": 10},
    )
    por_ano = defaultdict(float)
    for p in r.json():
        if p["type"] in ("DIVIDEND", "JCP"):
            ano = int(p["ex_date"][:4])
            por_ano[ano] += p["value"]

    # conta anos consecutivos a partir do ano passado para trás
    consecutivos = 0
    ano = date.today().year - 1
    while por_ano.get(ano, 0) >= minimo_por_ano:
        consecutivos += 1
        ano -= 1
    return consecutivos


print(anos_pagando("ITSA4"))

Começamos a contagem pelo ano anterior porque o ano corrente ainda está incompleto — em julho, uma empresa pode simplesmente não ter feito o pagamento anual dela. Exigir, digamos, cinco anos consecutivos elimina de vez as pagadoras de ocasião. O histórico completo de proventos exige o plano Pro; no plano gratuito você acessa o snapshot mais recente, o bastante para o DY atual e uma janela curta.

Filtro 4: endividamento, o freio dos dividendos futuros

Dividendos saem do caixa. Uma empresa muito endividada precisa priorizar o pagamento de dívida — e, quando aperta, o primeiro corte costuma ser justamente o dividendo. O indicador clássico é a dívida líquida sobre EBITDA, exposto no campo net_debt_ebitda de /fundamentals. Como referência geral, valores até cerca de 3x costumam ser considerados confortáveis para empresas não financeiras; acima disso, cautela.

def endividamento_ok(ticker: str, limite: float = 3.0) -> bool:
    fund = requests.get(
        f"{BASE}/fundamentals/{ticker}",
        params={"api_key": API_KEY},
    ).json()
    dl_ebitda = fund.get("net_debt_ebitda")
    if dl_ebitda is None:
        return True  # bancos/seguradoras não usam essa métrica
    return dl_ebitda <= limite

Bancos e seguradoras não se avaliam por dívida líquida/EBITDA — a estrutura de capital deles é outra. Por isso tratamos None como aprovado neste filtro e confiamos nos demais (ROE, payout, consistência) para essas empresas. Se quiser aprofundar o tema de solvência, veja o guia dedicado a payout ratio via API, que trata o payout como termômetro de sustentabilidade.

Juntando tudo: seu ranking vivo

Agora combinamos os quatro filtros num único fluxo. Começamos pelo screener (para não varrer a B3 inteira à mão), aplicamos os filtros de qualidade candidata a candidata e ordenamos o resultado. Você pode partir da saída do screener ou de uma lista sua de papéis costumeiramente associados a dividendos — como TAEE11, BBSE3, ITSA4, VIVT3, CPLE6, TRPL4 e BBAS3 — sem assumir de antemão qual paga mais: quem decide isso são os números do dia.

import requests
from datetime import date, timedelta
from collections import defaultdict

API_KEY = "sua_chave_aqui"
BASE = "https://api.usebolsai.com/api/v1"

# Critérios — ajuste conforme sua estratégia e o cenário de juros
DY_MIN = 6.0          # dividend_yield mínimo (%)
PAYOUT_MAX = 100.0     # payout acima disso é insustentável
ANOS_MIN = 4            # anos consecutivos pagando
DL_EBITDA_MAX = 3.0    # dívida líquida / EBITDA


def avaliar(ticker: str):
    fund = requests.get(
        f"{BASE}/fundamentals/{ticker}",
        params={"api_key": API_KEY},
    ).json()
    dy = fund.get("dividend_yield")
    lpa = fund.get("lpa")
    dl_ebitda = fund.get("net_debt_ebitda")

    if not dy or dy < DY_MIN:
        return None
    if dl_ebitda is not None and dl_ebitda > DL_EBITDA_MAX:
        return None

    # proventos TTM + consistência a partir de /dividends
    divs = requests.get(
        f"{BASE}/dividends/{ticker}",
        params={"api_key": API_KEY, "years": 10},
    ).json()
    corte = date.today() - timedelta(days=365)
    ttm = 0.0
    por_ano = defaultdict(float)
    for p in divs:
        if p["type"] in ("DIVIDEND", "JCP"):
            por_ano[int(p["ex_date"][:4])] += p["value"]
            if date.fromisoformat(p["ex_date"]) >= corte:
                ttm += p["value"]

    anos = 0
    ano = date.today().year - 1
    while por_ano.get(ano, 0) > 0:
        anos += 1
        ano -= 1
    if anos < ANOS_MIN:
        return None

    payout = round(ttm / lpa * 100, 1) if lpa and lpa > 0 else None
    if payout is not None and payout > PAYOUT_MAX:
        return None

    return {
        "ticker": ticker, "dy": dy, "payout": payout,
        "anos": anos, "dl_ebitda": dl_ebitda,
    }


# 1) pega a lista bruta do screener (ranking de hoje)
bruta = requests.get(
    f"{BASE}/screener",
    params={
        "api_key": API_KEY, "dividend_yield_gt": DY_MIN,
        "sort": "dividend_yield", "order": "desc", "limit": 50,
    },
).json()

# 2) aplica os filtros de qualidade
aprovadas = [r for t in (a["ticker"] for a in bruta)
             if (r := avaliar(t))]
aprovadas.sort(key=lambda x: x["dy"], reverse=True)

# 3) imprime o SEU ranking
print(f"{'Ticker':8}{'DY':>7}{'Payout':>9}{'Anos':>6}{'DL/EBITDA':>11}")
for a in aprovadas:
    print(f"{a['ticker']:8}{a['dy']:>6.1f}%{str(a['payout'])+'%':>9}"
          f"{a['anos']:>6}{str(a['dl_ebitda']):>11}")

A saída tem o formato abaixo. Reforçando: os valores são ilustrativos, apenas para mostrar o layout — os tickers e números reais que aparecerão dependem inteiramente do dia em que você executa o script. Não tome isto como recomendação nem como o ranking atual:

Esse é o ponto central do guia: o "ranking" não é um dado que eu forneço — é um artefato que o seu código gera. Amanhã, com preços novos, ele muda sozinho. É a diferença entre consumir uma lista que envelhece e ter um processo reproduzível.

Exportar para planilha e continuar a análise

Se preferir trabalhar no Excel, no Google Sheets ou no pandas, qualquer endpoint de listagem aceita ?format=csv. Para puxar o resultado do screener direto para um DataFrame:

import pandas as pd
from io import StringIO

r = requests.get(
    f"{BASE}/screener",
    params={
        "api_key": API_KEY, "format": "csv",
        "dividend_yield_gt": 8,
        "sort": "dividend_yield", "order": "desc", "limit": 30,
    },
)
df = pd.read_csv(StringIO(r.text))
print(df.head())

No Google Sheets, o mesmo endpoint com format=csv funciona dentro de =IMPORTDATA("..."), o que transforma sua planilha num painel que se atualiza sozinho a cada abertura.

Setores tradicionalmente associados a dividendos

No mercado brasileiro, alguns setores são historicamente lembrados por distribuir proventos com regularidade — geralmente empresas maduras, com fluxo de caixa previsível e baixa necessidade de reinvestir. Todos podem ser filtrados por sector no screener. Os tickers abaixo são apenas exemplos comumente citados; nenhum yield está sendo afirmado aqui — use a API para ver os números atuais de cada um.

Lembre que "setor tradicional de dividendos" descreve o passado, não garante o futuro. Uma elétrica pode cortar proventos para financiar uma expansão; um banco pode reter mais lucro num ciclo de crédito ruim. Por isso o processo — DY, payout, consistência e dívida — vale mais do que a reputação do setor.

Pergunte em linguagem natural com IA

Se você usa Claude, Cursor ou ChatGPT, dá para pular o código e conversar com os dados. A bolsai oferece um servidor MCP com ferramentas como screen_stocks, get_dividends e get_fundamentals. Você pode pedir algo como "rode um screening de ações da B3 com dividend yield acima de 8% e ROE acima de 10%" e o assistente chama a API por você. É a mesma metodologia deste guia, só que orquestrada por linguagem natural.

Perguntas frequentes

Qual é a melhor ação de dividendos em 2026?

Não há resposta fixa, e desconfie de quem der uma. O ranking muda a cada pregão porque o DY depende do preço, que a bolsai atualiza no fechamento (20:30 BRT). Rode o screener (/screener?dividend_yield_gt=8&sort=dividend_yield&order=desc) para a lista real de hoje e filtre por payout e endividamento antes de decidir.

Como saber se o dividend yield alto é uma armadilha?

DY muito alto costuma refletir queda de preço, não generosidade. Cheque o payout (proventos TTM sobre o lpa) — acima de 100% raramente se sustenta; o campo net_debt_ebitda; e a consistência dos pagamentos ano a ano com /dividends?years=N.

Os dados de dividendos da bolsai são em tempo real?

Não. São de fechamento, atualizados diariamente às 20:30 BRT após o pregão da B3; proventos e fundamentos são reprocessados semanalmente. As fontes são B3, CVM e BCB. A bolsai é informativa e analítica — não é corretora nem recomendação de investimento.

Preciso pagar para montar o ranking?

Não para começar. O plano gratuito oferece 200 requisições por dia, suficiente para rodar o screener e analisar dezenas de papéis. O plano Pro (R$49/mês) libera 10.000 requisições diárias e o histórico completo, útil para reconstruir a série de proventos de vários anos e medir consistência com rigor.

Leia também

• Dividend Yield (DY) via API da B3 — a fórmula, JCP vs dividendos e como o DY é calculado no fechamento
• Como montar uma carteira de dividendos com Python — do screening ao acompanhamento de yield on cost
• Ações de dividendos mensais em 2026 — como identificar quem paga com maior frequência ao longo do ano
• Payout ratio via API — o filtro que separa dividendos sustentáveis de insustentáveis
• Documentação completa — todos os endpoints, parâmetros e exemplos

Comece agora

Pegue uma chave gratuita e rode o screener hoje mesmo: 200 requisições por dia bastam para gerar e refinar seu ranking. Quando precisar de histórico longo para medir consistência de anos, o plano Pro (R$49/mês) libera 10.000 requisições diárias e a série completa de proventos.

Este conteúdo é informativo e educacional e não constitui recomendação de investimento. A bolsai não é corretora e não executa ordens. Dados de B3, CVM e BCB, de fechamento (20:30 BRT). Faça sua própria análise.