Como Declarar Criptomoedas no Imposto de Renda 2026/2027: Guia Completo DeCripto

┌─────────────────────────────────────────────────────────────────┐
│                    FLUXO DE DECLARAÇÃO                          │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  ┌─────────────┐    ┌─────────────┐    ┌─────────────────────┐ │
│  │   COMPRA    │───▶│   POSSE     │───▶│   VENDA > R$35K    │ │
│  │  Criptos    │    │   (DIRPF)   │    │   (DARF mensal)    │ │
│  └─────────────┘    └─────────────┘    └─────────────────────┘ │
│        │                  │                      │              │
│        ▼                  ▼                      ▼              │
│  ┌─────────────┐    ┌─────────────┐    ┌─────────────────────┐ │
│  │  DeCripto   │    │ Bens e      │    │  GCAP + DARF        │ │
│  │  (mensal)   │    │ Direitos    │    │  código 4600        │ │
│  └─────────────┘    └─────────────┘    └─────────────────────┘ │
│                                                                 │
└─────────────────────────────────────────────────────────────────┘

# Calculadora de Isenção de IR sobre Criptomoedas

def calcular_imposto_cripto(vendas_mes: list[dict]) -> dict:
    """
    Calcula se há imposto devido sobre vendas de cripto no mês.
    
    Args:
        vendas_mes: Lista de vendas com 'valor_venda' e 'custo_aquisicao'
    
    Returns:
        Dicionário com análise tributária
    """
    LIMITE_ISENCAO = 35000.00
    
    # Alíquotas progressivas de ganho de capital
    ALIQUOTAS = [
        (5_000_000, 0.15),      # Até R$ 5 milhões: 15%
        (10_000_000, 0.175),    # De R$ 5M a R$ 10M: 17.5%
        (30_000_000, 0.20),     # De R$ 10M a R$ 30M: 20%
        (float('inf'), 0.225),  # Acima de R$ 30M: 22.5%
    ]
    
    total_vendas = sum(v['valor_venda'] for v in vendas_mes)
    total_lucro = sum(
        max(0, v['valor_venda'] - v['custo_aquisicao']) 
        for v in vendas_mes
    )
    
    # Verifica isenção
    if total_vendas <= LIMITE_ISENCAO:
        return {
            'total_vendas': total_vendas,
            'lucro_bruto': total_lucro,
            'isento': True,
            'imposto_devido': 0,
            'motivo': f'Vendas ≤ R$ {LIMITE_ISENCAO:,.2f} - ISENTO'
        }
    
    # Calcula imposto progressivo
    imposto = 0
    lucro_restante = total_lucro
    
    for limite, aliquota in ALIQUOTAS:
        if lucro_restante <= 0:
            break
        
        faixa = min(lucro_restante, limite)
        imposto += faixa * aliquota
        lucro_restante -= faixa
    
    return {
        'total_vendas': total_vendas,
        'lucro_bruto': total_lucro,
        'isento': False,
        'imposto_devido': round(imposto, 2),
        'motivo': f'Vendas > R$ {LIMITE_ISENCAO:,.2f} - TRIBUTÁVEL'
    }


# Exemplo de uso
vendas_janeiro = [
    {'valor_venda': 25000, 'custo_aquisicao': 20000},  # BTC: lucro R$ 5k
    {'valor_venda': 15000, 'custo_aquisicao': 12000},  # ETH: lucro R$ 3k
]

resultado = calcular_imposto_cripto(vendas_janeiro)

print("=" * 50)
print("ANÁLISE TRIBUTÁRIA - CRIPTOMOEDAS")
print("=" * 50)
print(f"Total de vendas no mês: R$ {resultado['total_vendas']:,.2f}")
print(f"Lucro bruto: R$ {resultado['lucro_bruto']:,.2f}")
print(f"Status: {resultado['motivo']}")
print(f"Imposto devido: R$ {resultado['imposto_devido']:,.2f}")

==================================================
ANÁLISE TRIBUTÁRIA - CRIPTOMOEDAS
==================================================
Total de vendas no mês: R$ 40,000.00
Lucro bruto: R$ 8,000.00
Status: Vendas > R$ 35,000.00 - TRIBUTÁVEL
Imposto devido: R$ 1,200.00

from dataclasses import dataclass
from datetime import date
from typing import Optional
import requests

@dataclass
class OperacaoCripto:
    data: date
    tipo: str  # 'compra' ou 'venda'
    quantidade: float
    valor_unitario: float
    exchange: str
    
    @property
    def valor_total(self) -> float:
        return self.quantidade * self.valor_unitario


class CarteiraPrecoMedio:
    """Calcula preço médio ponderado de criptoativos."""
    
    def __init__(self, ticker: str):
        self.ticker = ticker
        self.quantidade_total = 0.0
        self.custo_total = 0.0
        self.operacoes: list[OperacaoCripto] = []
        self.historico_vendas: list[dict] = []
    
    @property
    def preco_medio(self) -> float:
        if self.quantidade_total <= 0:
            return 0.0
        return self.custo_total / self.quantidade_total
    
    def registrar_compra(self, op: OperacaoCripto) -> None:
        """Registra compra e atualiza preço médio."""
        self.quantidade_total += op.quantidade
        self.custo_total += op.valor_total
        self.operacoes.append(op)
        
        print(f"[COMPRA] {op.quantidade:.8f} {self.ticker} @ R$ {op.valor_unitario:,.2f}")
        print(f"  → Novo preço médio: R$ {self.preco_medio:,.2f}")
    
    def registrar_venda(self, op: OperacaoCripto) -> dict:
        """Registra venda e calcula ganho/perda."""
        if op.quantidade > self.quantidade_total:
            raise ValueError("Quantidade insuficiente para venda")
        
        custo_venda = op.quantidade * self.preco_medio
        lucro = op.valor_total - custo_venda
        
        # Atualiza posição
        self.quantidade_total -= op.quantidade
        self.custo_total -= custo_venda
        self.operacoes.append(op)
        
        resultado = {
            'data': op.data,
            'quantidade': op.quantidade,
            'valor_venda': op.valor_total,
            'custo_aquisicao': custo_venda,
            'lucro': lucro,
            'preco_medio_usado': self.preco_medio
        }
        
        self.historico_vendas.append(resultado)
        
        status = "LUCRO" if lucro > 0 else "PREJUÍZO"
        print(f"[VENDA] {op.quantidade:.8f} {self.ticker} @ R$ {op.valor_unitario:,.2f}")
        print(f"  → {status}: R$ {abs(lucro):,.2f}")
        
        return resultado
    
    def gerar_relatorio_ir(self) -> str:
        """Gera relatório para declaração de IR."""
        total_lucro = sum(v['lucro'] for v in self.historico_vendas)
        total_vendas = sum(v['valor_venda'] for v in self.historico_vendas)
        
        relatorio = f"""
╔════════════════════════════════════════════════════════════════╗
║         RELATÓRIO PARA IMPOSTO DE RENDA - {self.ticker}         ║
╠════════════════════════════════════════════════════════════════╣
║ Posição Atual                                                   ║
║   Quantidade: {self.quantidade_total:>20.8f} {self.ticker}      ║
║   Custo Total: R$ {self.custo_total:>17,.2f}                    ║
║   Preço Médio: R$ {self.preco_medio:>17,.2f}                    ║
╠════════════════════════════════════════════════════════════════╣
║ Resumo de Vendas no Período                                     ║
║   Total Vendido: R$ {total_vendas:>15,.2f}                      ║
║   Lucro/Prejuízo: R$ {total_lucro:>14,.2f}                      ║
╚════════════════════════════════════════════════════════════════╝
"""
        return relatorio


# Exemplo de uso
carteira_btc = CarteiraPrecoMedio("BTC")

# Registrar compras
carteira_btc.registrar_compra(OperacaoCripto(
    data=date(2024, 1, 15),
    tipo='compra',
    quantidade=0.1,
    valor_unitario=220000,
    exchange='Mercado Bitcoin'
))

carteira_btc.registrar_compra(OperacaoCripto(
    data=date(2024, 3, 20),
    tipo='compra',
    quantidade=0.05,
    valor_unitario=350000,
    exchange='Binance'
))

# Registrar venda
carteira_btc.registrar_venda(OperacaoCripto(
    data=date(2024, 11, 10),
    tipo='venda',
    quantidade=0.08,
    valor_unitario=580000,
    exchange='Mercado Bitcoin'
))

print(carteira_btc.gerar_relatorio_ir())

BITCOIN (BTC)
Quantidade: 0.15000000 BTC
Custodiado em: Mercado Bitcoin (CNPJ: XX.XXX.XXX/0001-XX)
Data da primeira aquisição: 15/01/2024
Preço médio de aquisição: R$ 256.666,67/BTC

def gerar_darf_info(mes: int, ano: int, lucro: float) -> dict:
    """
    Gera informações para pagamento de DARF sobre ganho de capital em cripto.
    """
    from datetime import date, timedelta
    
    # Data de vencimento: último dia útil do mês seguinte
    if mes == 12:
        mes_venc = 1
        ano_venc = ano + 1
    else:
        mes_venc = mes + 1
        ano_venc = ano
    
    # Simplificação: último dia do mês (ajustar para dia útil)
    if mes_venc in [1, 3, 5, 7, 8, 10, 12]:
        ultimo_dia = 31
    elif mes_venc in [4, 6, 9, 11]:
        ultimo_dia = 30
    else:
        ultimo_dia = 28  # Simplificado
    
    vencimento = date(ano_venc, mes_venc, ultimo_dia)
    
    # Cálculo do imposto (15% para maioria dos casos)
    imposto = lucro * 0.15
    
    return {
        'codigo_receita': '4600',
        'descricao': 'IRPF - Ganho de Capital - Alienação de Moeda Estrangeira/Criptoativo',
        'periodo_apuracao': f'{mes:02d}/{ano}',
        'vencimento': vencimento.strftime('%d/%m/%Y'),
        'valor_principal': round(imposto, 2),
        'cnpj_beneficiario': None,  # Pessoa física não preenche
        'observacao': f'Ganho de capital em criptoativos - {mes:02d}/{ano}'
    }


# Exemplo
info_darf = gerar_darf_info(mes=11, ano=2024, lucro=8000)

print("INFORMAÇÕES PARA DARF")
print("=" * 40)
for campo, valor in info_darf.items():
    print(f"{campo}: {valor}")

from datetime import date
from dateutil.relativedelta import relativedelta

def calcular_darf_atrasado(
    valor_original: float,
    data_vencimento: date,
    data_pagamento: date,
    taxa_selic_acumulada: float = 0.1075  # ~10.75% a.a. exemplo
) -> dict:
    """
    Calcula DARF em atraso com multa e juros.
    
    Multa: 0.33% ao dia, limitada a 20%
    Juros: Taxa SELIC acumulada
    """
    if data_pagamento <= data_vencimento:
        return {
            'valor_original': valor_original,
            'multa': 0,
            'juros': 0,
            'valor_total': valor_original
        }
    
    # Dias de atraso
    dias_atraso = (data_pagamento - data_vencimento).days
    
    # Multa: 0.33% ao dia, máximo 20%
    multa_percentual = min(dias_atraso * 0.0033, 0.20)
    multa = valor_original * multa_percentual
    
    # Juros: SELIC do período (simplificado)
    meses_atraso = dias_atraso / 30
    juros_percentual = (taxa_selic_acumulada / 12) * meses_atraso
    juros = valor_original * juros_percentual
    
    valor_total = valor_original + multa + juros
    
    return {
        'valor_original': round(valor_original, 2),
        'dias_atraso': dias_atraso,
        'multa_percentual': f"{multa_percentual * 100:.2f}%",
        'multa': round(multa, 2),
        'juros': round(juros, 2),
        'valor_total': round(valor_total, 2)
    }


# Exemplo: DARF de novembro/2024 pago em atraso
resultado = calcular_darf_atrasado(
    valor_original=1200.00,
    data_vencimento=date(2024, 12, 31),
    data_pagamento=date(2026, 2, 15)  # 46 dias de atraso
)

print("CÁLCULO DARF EM ATRASO")
print("=" * 40)
for k, v in resultado.items():
    print(f"{k}: {v}")

┌─────────────────────────────────────────────────────────────────┐
│                    FLUXO DeCripto                               │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  Exchange Brasileira                Exchange Estrangeira         │
│  (Binance BR, MB, etc.)            (Binance Global, Coinbase)   │
│          │                                   │                   │
│          ▼                                   ▼                   │
│  ┌───────────────┐                   ┌───────────────┐          │
│  │ Exchange      │                   │ VOCÊ declara  │          │
│  │ declara por   │                   │ se operações  │          │
│  │ você (auto)   │                   │ > R$ 30k/mês  │          │
│  └───────────────┘                   └───────────────┘          │
│                                                                 │
│  Operações P2P / DEX                                            │
│          │                                                       │
│          ▼                                                       │
│  ┌───────────────────────────────────┐                          │
│  │ VOCÊ declara se > R$ 30k/mês     │                          │
│  └───────────────────────────────────┘                          │
│                                                                 │
└─────────────────────────────────────────────────────────────────┘

import requests
from datetime import datetime
from dataclasses import dataclass
from typing import Optional

@dataclass
class ConfiguracaoIR:
    limite_isencao_mensal: float = 35000.00
    codigo_darf: str = "4600"
    aliquotas: list = None
    
    def __post_init__(self):
        if self.aliquotas is None:
            self.aliquotas = [
                (5_000_000, 0.15),
                (10_000_000, 0.175),
                (30_000_000, 0.20),
                (float('inf'), 0.225),
            ]


class CalculadoraIRCripto:
    """
    Calculadora completa de Imposto de Renda sobre criptomoedas.
    """
    
    def __init__(self, config: Optional[ConfiguracaoIR] = None):
        self.config = config or ConfiguracaoIR()
        self.operacoes_mes: dict = {}  # {mes: [operacoes]}
    
    def obter_cotacao_brapi(self, moeda: str = "BTC") -> Optional[float]:
        """Obtém cotação atual via brapi.dev"""
        try:
            url = f"https://brapi.dev/api/v2/crypto?coin={moeda}&currency=BRL"
            response = requests.get(url, timeout=10)
            data = response.json()
            
            if 'coins' in data and len(data['coins']) > 0:
                return data['coins'][0].get('regularMarketPrice')
        except Exception as e:
            print(f"Erro ao obter cotação: {e}")
        return None
    
    def adicionar_venda(
        self, 
        mes: str,  # formato "MM/YYYY"
        valor_venda: float,
        custo_aquisicao: float,
        moeda: str = "BTC"
    ) -> None:
        """Adiciona uma operação de venda."""
        if mes not in self.operacoes_mes:
            self.operacoes_mes[mes] = []
        
        self.operacoes_mes[mes].append({
            'moeda': moeda,
            'valor_venda': valor_venda,
            'custo_aquisicao': custo_aquisicao,
            'lucro': valor_venda - custo_aquisicao
        })
    
    def calcular_imposto_mes(self, mes: str) -> dict:
        """Calcula imposto devido para um mês específico."""
        if mes not in self.operacoes_mes:
            return {'mes': mes, 'isento': True, 'imposto': 0}
        
        operacoes = self.operacoes_mes[mes]
        total_vendas = sum(op['valor_venda'] for op in operacoes)
        total_lucro = sum(max(0, op['lucro']) for op in operacoes)
        
        # Verifica isenção
        if total_vendas <= self.config.limite_isencao_mensal:
            return {
                'mes': mes,
                'total_vendas': total_vendas,
                'total_lucro': total_lucro,
                'isento': True,
                'imposto': 0,
                'motivo': 'Vendas dentro do limite de isenção'
            }
        
        # Calcula imposto progressivo
        imposto = 0
        lucro_restante = total_lucro
        detalhamento = []
        
        for limite, aliquota in self.config.aliquotas:
            if lucro_restante <= 0:
                break
            
            faixa = min(lucro_restante, limite)
            imposto_faixa = faixa * aliquota
            imposto += imposto_faixa
            lucro_restante -= faixa
            
            detalhamento.append({
                'faixa_ate': limite,
                'aliquota': f"{aliquota*100}%",
                'base': faixa,
                'imposto': imposto_faixa
            })
        
        return {
            'mes': mes,
            'total_vendas': total_vendas,
            'total_lucro': total_lucro,
            'isento': False,
            'imposto': round(imposto, 2),
            'detalhamento': detalhamento,
            'codigo_darf': self.config.codigo_darf
        }
    
    def gerar_relatorio_anual(self) -> str:
        """Gera relatório anual para declaração."""
        relatorio = []
        relatorio.append("=" * 60)
        relatorio.append("RELATÓRIO ANUAL - IR SOBRE CRIPTOMOEDAS")
        relatorio.append("=" * 60)
        
        total_vendas_ano = 0
        total_lucro_ano = 0
        total_imposto_ano = 0
        
        for mes in sorted(self.operacoes_mes.keys()):
            resultado = self.calcular_imposto_mes(mes)
            
            total_vendas_ano += resultado.get('total_vendas', 0)
            total_lucro_ano += resultado.get('total_lucro', 0)
            total_imposto_ano += resultado.get('imposto', 0)
            
            status = "ISENTO" if resultado['isento'] else "TRIBUTÁVEL"
            relatorio.append(f"\n{mes}: {status}")
            relatorio.append(f"  Vendas: R$ {resultado.get('total_vendas', 0):,.2f}")
            relatorio.append(f"  Lucro: R$ {resultado.get('total_lucro', 0):,.2f}")
            relatorio.append(f"  Imposto: R$ {resultado.get('imposto', 0):,.2f}")
        
        relatorio.append("\n" + "=" * 60)
        relatorio.append("RESUMO ANUAL")
        relatorio.append("=" * 60)
        relatorio.append(f"Total de vendas: R$ {total_vendas_ano:,.2f}")
        relatorio.append(f"Lucro total: R$ {total_lucro_ano:,.2f}")
        relatorio.append(f"Imposto total devido: R$ {total_imposto_ano:,.2f}")
        
        return "\n".join(relatorio)


# Exemplo de uso
calc = CalculadoraIRCripto()

# Adicionar operações do ano
calc.adicionar_venda("01/2024", 20000, 15000, "BTC")  # Isento
calc.adicionar_venda("03/2024", 40000, 30000, "BTC")  # Tributável
calc.adicionar_venda("03/2024", 10000, 8000, "ETH")   # Soma com BTC
calc.adicionar_venda("06/2024", 25000, 20000, "SOL")  # Isento
calc.adicionar_venda("11/2024", 50000, 35000, "BTC")  # Tributável

print(calc.gerar_relatorio_anual())

# Obter cotação atual
cotacao = calc.obter_cotacao_brapi("BTC")
if cotacao:
    print(f"\nCotação atual BTC: R$ {cotacao:,.2f}")

import requests
from datetime import datetime

def obter_portfolio_cripto(moedas: list[str], token: str = None) -> dict:
    """
    Obtém cotações atuais de múltiplas criptomoedas via brapi.dev.
    """
    resultados = {}
    
    for moeda in moedas:
        url = f"https://brapi.dev/api/v2/crypto?coin={moeda}&currency=BRL"
        
        if token:
            url += f"&token={token}"
        
        try:
            response = requests.get(url, timeout=10)
            data = response.json()
            
            if 'coins' in data and len(data['coins']) > 0:
                coin_data = data['coins'][0]
                resultados[moeda] = {
                    'nome': coin_data.get('coinName'),
                    'preco_brl': coin_data.get('regularMarketPrice'),
                    'variacao_24h': coin_data.get('regularMarketChangePercent'),
                    'market_cap': coin_data.get('marketCap'),
                    'volume_24h': coin_data.get('regularMarketVolume')
                }
        except Exception as e:
            resultados[moeda] = {'erro': str(e)}
    
    return resultados


def calcular_valor_portfolio(
    holdings: dict,  # {'BTC': 0.5, 'ETH': 2.0}
    token: str = None
) -> dict:
    """
    Calcula valor total do portfólio para declaração.
    """
    moedas = list(holdings.keys())
    cotacoes = obter_portfolio_cripto(moedas, token)
    
    portfolio = {
        'data_consulta': datetime.now().isoformat(),
        'ativos': [],
        'valor_total_brl': 0
    }
    
    for moeda, quantidade in holdings.items():
        if moeda in cotacoes and 'preco_brl' in cotacoes[moeda]:
            preco = cotacoes[moeda]['preco_brl']
            valor = quantidade * preco
            
            portfolio['ativos'].append({
                'moeda': moeda,
                'quantidade': quantidade,
                'preco_unitario': preco,
                'valor_total': valor
            })
            
            portfolio['valor_total_brl'] += valor
    
    return portfolio


# Exemplo: Calcular valor para declaração
meu_portfolio = {
    'BTC': 0.15,
    'ETH': 1.5,
    'SOL': 10
}

resultado = calcular_valor_portfolio(meu_portfolio)

print("VALOR DO PORTFÓLIO PARA DECLARAÇÃO")
print("=" * 50)
print(f"Data: {resultado['data_consulta'][:10]}")
print("\nAtivos:")

for ativo in resultado['ativos']:
    print(f"  {ativo['moeda']}: {ativo['quantidade']:.8f}")
    print(f"    Preço: R$ {ativo['preco_unitario']:,.2f}")
    print(f"    Valor: R$ {ativo['valor_total']:,.2f}")

print(f"\nVALOR TOTAL: R$ {resultado['valor_total_brl']:,.2f}")