Como Usar Claude Code para Analise de Dados — Guia Pratico

Voce tem dados. CSVs de vendas, exports do Google Analytics, planilhas de estoque, relatorios do ERP. Mas transformar tudo isso em insights acionaveis e a parte que trava. Formulas complexas no Excel, linguagem R que ninguem entende, dashboards de BI que custam milhares por mes.

O Claude Code resolve isso de um jeito simples: voce aponta para um arquivo de dados, pergunta o que quer saber em portugues, e ele analisa, processa e responde. Sem formulas, sem programacao, sem ferramentas caras.

Neste guia, voce vai ver exemplos reais de analise de dados com Claude Code -- de CSVs simples a queries SQL, de metricas de GA4 a dashboards interativos.

1. Por que Claude Code para dados

O Claude Code tem uma vantagem critica sobre chatbots comuns para analise de dados: ele acessa seus arquivos diretamente e executa codigo no seu terminal. Isso significa que:

• Nao precisa copiar dados para um chat -- ele le o arquivo direto do seu computador
• Processa arquivos grandes -- CSVs com milhoes de linhas, que nao caberiam em um chat
• Gera scripts reutilizaveis -- a analise vira um script Python que voce roda todo mes
• Executa e mostra resultados -- nao e so sugestao de codigo, ele roda e mostra o output
• Itera sobre erros -- se o CSV tem encoding errado ou colunas inesperadas, ele detecta e ajusta

2. Analisando arquivos CSV

CSV e o formato mais comum para troca de dados. O Claude Code le e analisa qualquer CSV, independente do tamanho ou formato.

Passo 1: exploracao inicial

O Claude Code executa um script com pandas e retorna:

# Output do Claude Code:
# - 15.432 linhas, 8 colunas
# - Colunas: data, produto, categoria, quantidade, valor_unitario,
#   valor_total, cliente, regiao
# - Tipos: data (datetime), produto (str), categoria (str),
#   quantidade (int), valor_unitario (float), valor_total (float),
#   cliente (str), regiao (str)
# - Valores nulos: regiao tem 234 nulos (1.5%)
# - Periodo: 01/01/2025 a 31/12/2025

Passo 2: perguntas especificas

Agora que voce conhece a estrutura, pergunte o que precisa:

O Claude Code gera e executa o script de analise, apresentando cada resposta com dados concretos. Se ele detectar anomalias (como um dia com faturamento 10x acima da media), ele alerta e investiga automaticamente.

3. Exemplo: analise de vendas completa

Vamos ver um exemplo end-to-end. Voce tem um CSV de vendas e quer um relatorio completo:

O Claude Code gera um script completo:

# analise_vendas.py
import pandas as pd
from pathlib import Path

def carregar_dados(filepath: str) -> pd.DataFrame:
    """Carrega e prepara os dados de vendas."""
    df = pd.read_csv(filepath, parse_dates=["data"])
    df["mes"] = df["data"].dt.to_period("M")
    df["trimestre"] = df["data"].dt.to_period("Q")
    df["dia_semana"] = df["data"].dt.day_name()
    return df

def resumo_executivo(df: pd.DataFrame) -> dict:
    """Metricas principais do periodo."""
    return {
        "faturamento_total": df["valor_total"].sum(),
        "ticket_medio": df["valor_total"].mean(),
        "total_pedidos": len(df),
        "clientes_unicos": df["cliente"].nunique(),
        "produtos_vendidos": df["produto"].nunique(),
        "periodo": f"{df['data'].min():%d/%m/%Y} a {df['data'].max():%d/%m/%Y}",
    }

def analise_mensal(df: pd.DataFrame) -> pd.DataFrame:
    """Faturamento e pedidos por mes com variacao."""
    mensal = df.groupby("mes").agg(
        receita=("valor_total", "sum"),
        pedidos=("valor_total", "count"),
        ticket_medio=("valor_total", "mean"),
    )
    mensal["var_pct"] = mensal["receita"].pct_change() * 100
    return mensal

def top_produtos(df: pd.DataFrame, n: int = 10) -> pd.DataFrame:
    """Top N produtos por receita."""
    return (
        df.groupby("produto")
        .agg(receita=("valor_total", "sum"), qtd=("quantidade", "sum"))
        .sort_values("receita", ascending=False)
        .head(n)
    )

def analise_cohort(df: pd.DataFrame) -> dict:
    """Novos vs recorrentes por mes."""
    primeira_compra = df.groupby("cliente")["data"].min().reset_index()
    primeira_compra.columns = ["cliente", "primeira_compra"]
    merged = df.merge(primeira_compra, on="cliente")
    merged["tipo"] = merged.apply(
        lambda r: "novo" if r["data"].to_period("M") == r["primeira_compra"].to_period("M") else "recorrente",
        axis=1,
    )
    return merged.groupby(["mes", "tipo"])["valor_total"].sum().unstack(fill_value=0)

if __name__ == "__main__":
    df = carregar_dados("vendas-2025.csv")

    resumo = resumo_executivo(df)
    print("=== RESUMO EXECUTIVO ===")
    print(f"Faturamento: R$ {resumo['faturamento_total']:,.2f}")
    print(f"Ticket medio: R$ {resumo['ticket_medio']:,.2f}")
    print(f"Pedidos: {resumo['total_pedidos']:,}")
    print(f"Clientes unicos: {resumo['clientes_unicos']:,}")

    print("\n=== TOP 10 PRODUTOS ===")
    print(top_produtos(df).to_string())

    print("\n=== ANALISE MENSAL ===")
    print(analise_mensal(df).to_string())

Esse script e reutilizavel. Todo mes, atualize o CSV e rode python analise_vendas.py para ter o relatorio atualizado.

4. Analisando dados do GA4

O Google Analytics 4 permite exportar dados em CSV ou conectar via BigQuery. O Claude Code analisa ambos os formatos.

Exportacao CSV do GA4

O Claude Code le o export, identifica as metricas relevantes (sessions, engaged_sessions, conversions, bounce_rate) e gera insights acionaveis. Ele pode comparar com periodos anteriores se voce fornecer os dois arquivos.

Cruzando GA4 com dados de vendas

A capacidade de cruzar multiplos datasets e onde o Claude Code realmente se destaca. Ele le ambos os arquivos, faz o join por data (ou outra chave), e gera analises que seriam complexas em qualquer outra ferramenta.

5. Trabalhando com SQL

O Claude Code tambem trabalha com bancos de dados SQL. Para SQLite, ele acessa diretamente. Para PostgreSQL e MySQL, ele gera scripts de conexao.

# O Claude Code executa:
import sqlite3
import pandas as pd

conn = sqlite3.connect("dados/app.db")

# Schema
tables = pd.read_sql("SELECT name FROM sqlite_master WHERE type='table'", conn)
for table in tables["name"]:
    schema = pd.read_sql(f"PRAGMA table_info({table})", conn)
    count = pd.read_sql(f"SELECT COUNT(*) as total FROM {table}", conn)
    print(f"\n{table}: {count['total'].iloc[0]} registros")
    print(schema[["name", "type", "notnull"]].to_string(index=False))

# Top 10 clientes
top_clientes = pd.read_sql("""
    SELECT c.nome, COUNT(p.id) as total_pedidos,
           SUM(p.valor) as valor_total
    FROM clientes c
    JOIN pedidos p ON c.id = p.cliente_id
    GROUP BY c.id
    ORDER BY valor_total DESC
    LIMIT 10
""", conn)
print("\nTop 10 clientes:")
print(top_clientes.to_string(index=False))

Otimizacao de queries

O Claude Code tambem ajuda a otimizar queries lentas:

6. Criando visualizacoes e dashboards

Dados em tabela sao uteis, mas graficos comunicam melhor. O Claude Code pode gerar visualizacoes de varias formas:

Graficos com matplotlib

import matplotlib.pyplot as plt
import pandas as pd

df = pd.read_csv("vendas-2025.csv", parse_dates=["data"])

# 1. Faturamento mensal
mensal = df.set_index("data").resample("ME")["valor_total"].sum()
fig, ax = plt.subplots(figsize=(12, 5))
mensal.plot(kind="bar", ax=ax, color="#0ea5e9")
ax.set_title("Faturamento Mensal 2025", fontweight="bold", fontsize=14)
ax.set_ylabel("R$")
ax.set_xticklabels([d.strftime("%b") for d in mensal.index], rotation=0)
for i, v in enumerate(mensal.values):
    ax.text(i, v + v * 0.02, f"R${v:,.0f}", ha="center", fontsize=8)
plt.tight_layout()
plt.savefig("graficos/faturamento-mensal.png", dpi=150)
plt.close()

# 2. Distribuicao por categoria
por_cat = df.groupby("categoria")["valor_total"].sum().sort_values(ascending=False)
fig, ax = plt.subplots(figsize=(8, 8))
ax.pie(por_cat.values, labels=por_cat.index, autopct="%1.1f%%", startangle=90)
ax.set_title("Distribuicao por Categoria", fontweight="bold")
plt.savefig("graficos/categorias.png", dpi=150)
plt.close()

Dashboard HTML interativo

Para algo mais sofisticado, o Claude Code pode gerar um dashboard HTML completo com Chart.js:

O resultado e um arquivo HTML que voce abre no navegador -- com graficos interativos, hover com valores, responsivo no celular. Sem instalar nada, sem servidor, so abrir o arquivo.

7. Gerando relatorios automatizados

O Claude Code pode gerar relatorios formatados em varios formatos:

Formato	Quando usar	Como o Claude Code gera
Markdown	Relatorios internos, documentacao	Gera .md com tabelas, headers e metricas
HTML	Compartilhar com clientes/equipe	Pagina formatada com graficos
CSV	Dados processados para reimportar	Export limpo com metricas calculadas
JSON	Integracao com outros sistemas	Dados estruturados para APIs

8. Automacao de analises recorrentes

A parte mais poderosa: transformar analises manuais em scripts automatizados que rodam toda semana ou todo mes.

Script reutilizavel com parametros

# relatorio.py
import click
import pandas as pd
from pathlib import Path

@click.command()
@click.option("--arquivo", required=True, help="Caminho do CSV de vendas")
@click.option("--periodo", default="mes", type=click.Choice(["mes", "trimestre", "ano"]))
@click.option("--formato", default="markdown", type=click.Choice(["markdown", "html", "json"]))
@click.option("--output", default=None, help="Arquivo de saida")
def gerar_relatorio(arquivo, periodo, formato, output):
    """Gera relatorio de vendas a partir de CSV."""
    df = pd.read_csv(arquivo, parse_dates=["data"])
    # ... analise completa ...
    click.echo(f"Relatorio gerado: {output}")

if __name__ == "__main__":
    gerar_relatorio()

# Uso:
# python relatorio.py --arquivo vendas.csv --periodo mes --formato html --output relatorio-abril.html

Combinando com /loop para monitoramento

Monitoramento automatizado de KPIs em tempo real. O Claude Code roda a analise a cada hora e so alerta quando encontra anomalias.