Detetar Texto de IA em 2026: 12 Passos, 99% Acerto

Em 2026, quase qualquer texto que aparece numa caixa de correio, num trabalho académico ou num artigo online pode ter sido escrito, total ou parcialmente, por um modelo como o ChatGPT, o Claude, o Gemini, o DeepSeek ou o Llama. A partir de 2 de agosto de 2026, o Artigo 50 do AI Act da União Europeia passou a exigir que conteúdo gerado por IA seja identificável de forma legível por máquina, e que texto de IA publicado sobre assuntos de interesse público seja sinalizado como tal. Isto colocou a deteção de texto de IA no centro das preocupações de professores, editores, recrutadores e equipas de conformidade em Portugal.

O problema é que a maioria das ferramentas comerciais de deteção promete números de precisão que não resistem a testes independentes. Este tutorial mostra, passo a passo, como perceber as técnicas por trás da deteção de texto de IA, como usar as ferramentas mais conhecidas (GPTZero, Originality.ai, Copyleaks) e como construir o seu próprio detetor local em Python, combinando heurísticas estatísticas com verificação de marcas de água como a SynthID da Google e as Content Credentials da C2PA. No final, vai ter um serviço funcional, testado com texto real dos principais modelos de 2026.

O percurso está pensado para quem já programa em Python mas nunca construiu um pipeline de deteção: passa por perceber a teoria, testar as ferramentas comerciais manualmente, construir um detetor local do zero, ligar esse detetor a uma API externa e, por fim, publicar tudo como um pequeno serviço web pronto a integrar noutros sistemas. Cada passo inclui código funcional, não apenas pseudocódigo, e termina com uma lista de erros comuns e de problemas que provavelmente vai encontrar ao longo do caminho. Este é mais um tutorial prático dentro da nossa cobertura contínua de inteligência artificial e machine learning, focado desta vez na verificação de conteúdo em vez da criação de modelos.

Porque é que detetar texto de IA se tornou essencial em 2026

O volume de texto gerado por modelos de linguagem cresceu tão depressa que distinguir autoria humana de autoria sintética deixou de ser um exercício académico. Universidades usam detetores para avaliar trabalhos, editoras usam-nos para cumprir políticas editoriais, e agora o Artigo 50 do AI Act torna a rotulagem de conteúdo de IA uma obrigação legal para muitos casos de uso, com coimas que podem chegar aos 15 milhões de euros ou 3% do volume de negócios global da empresa infratora, consoante o valor mais alto. Já analisámos em detalhe as obrigações de transparência do AI Act noutro artigo. Aqui o foco é a parte prática: como implementar a verificação técnica que essas obrigações exigem.

Ao mesmo tempo, os próprios fabricantes de detetores admitem que a precisão varia muito conforme o contexto. A GPTZero, por exemplo, refere no seu material de referência sobre precisão que o objetivo é classificar corretamente texto de IA em 99 de cada 100 casos, um número validado internamente através do benchmark RAID, com 672 mil textos avaliados. Mas testes independentes de 2026 já situam a precisão real da GPTZero entre 79% e 85%, com modelos mais recentes como o GPT-5.6 a passarem despercebidos com frequência. Esta distância entre o marketing e o desempenho no mundo real é a razão principal para aprender a construir e combinar as suas próprias camadas de deteção, em vez de confiar cegamente numa única ferramenta.

Há também uma dimensão de desinformação que ultrapassa a sala de aula. Redações, verificadores de factos e equipas de comunicação institucional precisam cada vez mais de confirmar se um comunicado, um comentário em massa ou um testemunho publicado online tem origem humana. A Comissão Europeia descreve o Artigo 50 como resposta direta a este cenário, e disponibiliza o texto e as orientações de aplicação na página oficial do quadro regulatório para a IA. Para uma redação, isto significa que os mesmos princípios técnicos deste tutorial também servem para validar a origem de conteúdo recebido de terceiros antes de o publicar.

Como funcionam os detetores: perplexidade, burstiness e marcas de água

Existem três famílias de técnicas para detetar texto de IA, e é importante perceber as diferenças antes de escolher uma ferramenta. A primeira é estatística: mede a perplexidade (o quão “previsível” é cada palavra para um modelo de linguagem) e a burstiness (a variação de complexidade entre frases). Texto humano tende a alternar frases simples e complexas de forma irregular, enquanto texto de IA costuma manter um ritmo mais uniforme. O método DetectGPT, apresentado num artigo do ICML em 2023, usa uma variante desta ideia baseada em curvatura da função de probabilidade, e melhorou a deteção de notícias falsas de um AUROC de 0,81 (o melhor método anterior) para 0,95 em texto gerado por um modelo de 20 mil milhões de parâmetros. O artigo original, publicado no ICML em 2023 e disponível no arXiv, continua a ser a referência académica mais citada para métodos de deteção sem necessidade de treino próprio.

A segunda família são os classificadores treinados, como o da GPTZero, Originality.ai ou Copyleaks: redes neuronais treinadas especificamente para distinguir texto humano de texto sintético, geralmente acedidas via API ou interface web. A terceira família, mais recente, são as marcas de água embutidas na geração: a SynthID da Google DeepMind insere um padrão estatístico impercetível nos tokens de saída de modelos como o Gemini, e as Content Credentials da C2PA anexam metadados criptográficos assinados à origem do conteúdo. Ao contrário dos métodos estatísticos, uma marca de água bem implementada não perde precisão à medida que os modelos evoluem, porque não depende de adivinhar padrões: depende de uma assinatura colocada na hora da criação.

A limitação das marcas de água é a adoção: só funcionam se o modelo que gerou o texto as tiver embutido desde o início, e nem todos os fabricantes o fazem hoje. A Google aplica a SynthID ao Gemini, mas a OpenAI, a Anthropic e a Mistral não têm, até agosto de 2026, um equivalente público e verificável para texto simples. Por isso, na prática, um pipeline de deteção completo precisa de combinar as três famílias de técnicas, e não escolher apenas uma. Vale notar que detetar texto de IA é um problema diferente de detetar injeção de prompt: aqui procura-se identificar a origem de um texto já publicado, enquanto a injeção de prompt tenta manipular o comportamento de um modelo durante a própria geração.

Pré-requisitos: contas, chaves de API e ambiente de trabalho

Antes de avançar, prepare o seguinte ambiente. Não vai precisar de hardware especial: os exemplos correm num portátil comum.

Python 3.11 ou superior instalado, com pip e venv disponíveis
As bibliotecas transformers, torch, flask e requests, na versão mais recente estável disponível no PyPI
Uma conta gratuita na GPTZero (gptzero.me) para os primeiros testes, e uma chave de API se avançar para o plano Essential, a partir de 14,99 USD/mês para 150 mil palavras
Opcionalmente, uma conta na Originality.ai, com o plano Pro a partir de 14,95 USD/mês (2.000 créditos), para comparar resultados
Um editor de código (VS Code, PyCharm ou equivalente) e acesso a um terminal
Conhecimento básico de Python: funções, listas e pedidos HTTP simples

Não precisa de placa gráfica dedicada. O modelo GPT-2 usado nos exemplos locais corre confortavelmente em CPU, com tempos de resposta na ordem de um segundo por parágrafo num portátil comum. Se tiver acesso a uma GPU, mesmo modesta, os cálculos de perplexidade tornam-se praticamente instantâneos, o que interessa apenas se for processar volumes grandes de texto (por exemplo, moderação de comentários em massa).

Crie uma pasta de projeto e um ambiente virtual antes de instalar as dependências:

mkdir detetor-texto-ia
cd detetor-texto-ia
python3 -m venv venv
source venv/bin/activate
pip install transformers torch flask requests

Passo 1 e 2: mapear o objetivo e escolher a ferramenta certa

O primeiro passo real não é técnico: é decidir o que precisa de detetar e com que consequência. Verificar um único e-mail suspeito de phishing gerado por IA é muito diferente de rever centenas de trabalhos académicos por semana. Quanto maior a escala e o impacto de uma decisão errada (por exemplo, acusar um aluno de fraude académica), maior deve ser a exigência de precisão e de revisão humana antes de agir sobre o resultado de um detetor.

Com o objetivo definido, compare as três ferramentas comerciais mais usadas. A tabela seguinte junta números declarados pelos próprios fabricantes com resultados de testes independentes publicados ao longo de 2026, para que perceba a diferença entre o que é prometido e o que costuma acontecer na prática.

Ferramenta	Precisão declarada	Precisão em testes independentes (2026)	Falsos positivos	Preço de entrada
GPTZero	95,7% a 99,3% (RAID / Chicago Booth)	79% a 85%, com quebras adicionais em modelos recentes	~1% interno, até 18% em populações de estudantes de inglês como língua estrangeira	14,99 USD/mês (Essential, 150 mil palavras)
Originality.ai	99%+ nos modelos Lite e Turbo	76% a 87% em texto do GPT-5, cai para 62% com paráfrase	0,5% a 5,7%, conforme o estudo	14,95 USD/mês (Pro, 2.000 créditos)
Copyleaks	Mais de 99% (interno)	77% a 96%, cerca de 25% em texto “humanizado”	Abaixo de 0,2% (interno)	Plano institucional, sob consulta

Nenhuma das três é infalível, e todas caem a pique quando o texto é reescrito por uma ferramenta de “humanização” antes de ser publicado. Por isso, os passos seguintes ensinam a combinar mais do que uma fonte de sinal, em vez de confiar apenas num número.

A GPTZero afirma no seu material de referência sobre precisão que os seus resultados foram validados no RAID, um benchmark de terceiros, e que a ferramenta consegue identificar corretamente documentos mistos, com partes humanas e partes de IA, em cerca de 96,5% dos casos (fonte: página de referência sobre precisão da GPTZero). A Originality.ai, por seu lado, cita numa recolha própria de estudos uma precisão média entre 98% e 100% em vários testes de terceiros (fonte: resumo de estudos de deteção da Originality.ai). Vale a pena ler estas fontes diretamente antes de escolher, porque cada uma mede a precisão de forma ligeiramente diferente.

Passo 3 e 4: criar conta, obter a chave de API e testar manualmente

Registe-se em gptzero.me e, no painel, gere uma chave de API na secção de definições da conta. Antes de escrever qualquer código, faça um teste manual: cole um parágrafo escrito por si e um parágrafo gerado por um modelo como o Gemini ou o Claude na interface web da GPTZero, e compare os resultados. A escala de classificação, herdada da forma como o antigo classificador da OpenAI apresentava resultados antes de ser descontinuado a 20 de julho de 2023, costuma variar entre “muito improvável”, “improvável”, “indefinido”, “possível” e “provável” ser gerado por IA.

Este teste manual serve para calibrar expectativas: se um parágrafo seu, escrito à mão, for classificado como “possível” ou “provável” IA, já sabe que vai precisar de camadas adicionais de verificação antes de confiar no resultado, especialmente para texto em português, uma vez que a maioria destes classificadores foi treinada sobretudo em inglês.

Aproveite também a interface web para perceber os limites de tamanho de entrada. A maioria dos planos gratuitos aceita apenas alguns milhares de carateres por pedido, e documentos muito curtos (menos de 50 palavras) tendem a produzir resultados pouco fiáveis em qualquer ferramenta, porque não há sinal estatístico suficiente para uma classificação com confiança.

Passo 5 e 6: construir um detetor local com perplexidade e burstiness

Um detetor local, mesmo que menos sofisticado do que um serviço comercial, tem uma vantagem grande: corre offline, não tem limite de palavras mensal e serve como segunda opinião gratuita. O código seguinte usa um modelo aberto pequeno, como o GPT-2, para calcular a perplexidade de um texto. Textos com perplexidade muito baixa (o modelo “não se surpreende” com quase nenhuma palavra) são mais suspeitos de terem sido gerados por uma máquina.

import torch
from transformers import GPT2LMHeadModel, GPT2TokenizerFast

MODELO = "gpt2"
tokenizer = GPT2TokenizerFast.from_pretrained(MODELO)
modelo = GPT2LMHeadModel.from_pretrained(MODELO)
modelo.eval()

def calcular_perplexidade(texto):
    entradas = tokenizer(texto, return_tensors="pt")
    with torch.no_grad():
        saida = modelo(**entradas, labels=entradas["input_ids"])
    return torch.exp(saida.loss).item()

if __name__ == "__main__":
    texto_teste = "O relatório apresenta as conclusões da auditoria de segurança."
    print(f"Perplexidade: {calcular_perplexidade(texto_teste):.2f}")

Agora adicione o cálculo de burstiness, que mede a variação de perplexidade entre frases individuais. Divida o texto em frases, calcule a perplexidade de cada uma e obtenha o desvio-padrão: valores baixos indicam um ritmo demasiado uniforme, um sinal típico (mas não definitivo) de texto sintético.

import re
import statistics

def dividir_em_frases(texto):
    frases = re.split(r'(?<=[.!?]) +', texto.strip())
    return [f for f in frases if len(f) > 10]

def calcular_burstiness(texto):
    frases = dividir_em_frases(texto)
    if len(frases) < 3:
        return None
    perplexidades = [calcular_perplexidade(f) for f in frases]
    return statistics.stdev(perplexidades)

if __name__ == "__main__":
    texto_teste = "O relatório apresenta as conclusões da auditoria. A equipa identificou três falhas críticas. Foram propostas medidas corretivas imediatas."
    print(f"Burstiness: {calcular_burstiness(texto_teste)}")

A lógica por trás disto é simples de explicar: um modelo de linguagem gera cada palavra escolhendo a opção mais provável dado o contexto anterior. Quando outro modelo de linguagem (o seu detetor local) avalia esse mesmo texto, reconhece esse padrão de escolhas previsíveis e atribui-lhe uma perplexidade baixa. Texto humano, cheio de escolhas estilísticas menos óbvias, tende a surpreender mais o modelo avaliador, resultando em perplexidade mais alta. Esta relação não é perfeita, mas é a base teórica de praticamente todos os detetores estatísticos do mercado.

Passo 7: integrar a API da GPTZero no seu pipeline

Com a heurística local pronta, ligue-a a um serviço comercial para obter uma segunda opinião treinada em muito mais dados do que um GPT-2 conseguiria oferecer. O exemplo abaixo mostra o padrão típico de um pedido autenticado por chave de API, um formato comum à maioria destas ferramentas: envie o texto por POST, receba um JSON com uma pontuação. Confirme sempre o endpoint exato na documentação oficial da conta antes de usar em produção, porque estes detalhes mudam com frequência.

import requests
import os

CHAVE_API = os.environ.get("GPTZERO_API_KEY")
ENDPOINT = "https://api.gptzero.me/v2/predict/text"

def verificar_com_gptzero(texto):
    cabecalhos = {"x-api-key": CHAVE_API, "Content-Type": "application/json"}
    payload = {"document": texto}
    resposta = requests.post(ENDPOINT, json=payload, headers=cabecalhos, timeout=15)
    resposta.raise_for_status()
    dados = resposta.json()
    documento = dados["documents"][0]
    return documento.get("completely_generated_prob", None)

if __name__ == "__main__":
    prob = verificar_com_gptzero("Este texto foi escrito para testar a integração da API.")
    print(f"Probabilidade de ser gerado por IA: {prob}")

Note que o cabeçalho de autenticação e o nome exato dos campos no JSON de resposta podem variar consoante a versão da API que a sua conta usa. Trate este código como um ponto de partida, não como uma cópia definitiva do contrato da API.

Em produção, adicione sempre tratamento de erros para limites de utilização: um plano Essential com 150 mil palavras por mês esgota-se depressa se o serviço receber tráfego imprevisível. Capture o código de estado 429 separadamente, registe o momento em que ocorreu, e faça o pipeline recorrer automaticamente à heurística local (perplexidade e burstiness) quando a API externa não estiver disponível, em vez de falhar por completo.

Passo 8: verificar marcas de água SynthID e Content Credentials (C2PA)

Para conteúdo gerado no ecossistema Google, a SynthID oferece um caminho mais fiável do que a estatística: a DeepMind afirma ter avaliado quase 20 milhões de respostas do Gemini com esta marca de água ativa, sem diferença significativa na satisfação dos utilizadores. Desde novembro de 2025, o “Unified SynthID Detector” está integrado na app Gemini, permitindo colar texto suspeito e pedir uma verificação direta de marca de água, em vez de depender de heurísticas externas. Se também trabalha com a API do Gemini para gerar conteúdo, vale a pena rever o nosso guia sobre como testar a segurança da API do Gemini, que cobre configurações complementares a este fluxo de verificação.

Para imagens, áudio e vídeo com origem em ferramentas como o DALL-E, o Sora ou o Firefly da Adobe, use o standard aberto da C2PA, que em fevereiro de 2026 lançou a versão 2.3 das Content Credentials, já com mais de 6.000 membros e afiliados a implementá-la. Pode inspecionar o manifesto de proveniência de um ficheiro com a ferramenta de linha de comandos open source c2patool:

c2patool ficheiro-suspeito.jpg --detailed

Vale sublinhar uma limitação importante: até agosto de 2026, a OpenAI não lançou um verificador de marca de água dedicado a texto simples. A empresa descontinuou o seu classificador de texto original em 2023 por falta de precisão e concentrou os esforços de proveniência em imagem e, desde maio de 2026, também em áudio, através de marcas SynthID e Content Credentials combinadas. Ou seja, para texto puro do ChatGPT, continua a não existir uma marca de água oficial e verificável, o que reforça a necessidade dos métodos estatísticos e dos classificadores treinados descritos nos passos anteriores.

A versão 2.3 das Content Credentials, lançada em fevereiro de 2026, também introduziu um Programa de Conformidade que substitui a antiga “Lista de Confiança Interina”, congelada a 1 de janeiro de 2026. Isto significa que, ao verificar um manifesto C2PA hoje, deve confirmar não só que existe uma assinatura, mas também que a autoridade certificadora está na lista oficial de confiança atual, e não apenas na lista interina descontinuada.

Passo 9 e 10: criar um detetor combinado e testar com texto real

Nenhum sinal isolado é suficiente. A função seguinte combina a perplexidade local, a burstiness e a pontuação da API externa num único veredito, com pesos que pode ajustar consoante a experiência acumulada com o seu tipo de texto.

def detetar_texto_ia(texto):
    perplexidade = calcular_perplexidade(texto)
    burstiness = calcular_burstiness(texto) or 0
    prob_api = verificar_com_gptzero(texto) or 0

    sinal_perplexidade = 1.0 if perplexidade < 25 else 0.0
    sinal_burstiness = 1.0 if burstiness < 5 else 0.0
    pontuacao = (0.25 * sinal_perplexidade) + (0.25 * sinal_burstiness) + (0.5 * prob_api)

    if pontuacao >= 0.66:
        veredito = "provável IA"
    elif pontuacao >= 0.33:
        veredito = "indeterminado"
    else:
        veredito = "provável humano"

    return {"pontuacao": round(pontuacao, 2), "veredito": veredito}

Ao testar este tipo de pipeline com texto real de diferentes modelos, a taxa de deteção varia bastante consoante a origem. Um levantamento de 2026 que combinou os resultados de vários detetores (Turnitin, GPTZero e Originality.ai) mostrou que o Claude é o modelo mais difícil de identificar, e o DeepSeek o mais fácil, o que confirma que um bom detetor precisa de ser testado contra vários modelos, não apenas contra o mais popular. Esta dificuldade acrescida com o Claude também aparece noutro contexto: já mostrámos como a Anthropic reduziu a taxa de sucesso de ataques de prompt injection no Claude Opus 5, o que sugere que o mesmo cuidado com o estilo de saída do modelo pode estar a tornar o texto mais difícil de distinguir de escrita humana.

Os pesos usados na função detetar_texto_ia (0,25 para cada sinal estatístico, 0,5 para a API externa) refletem o facto de os classificadores comerciais, treinados em muito mais dados, tenderem a ser mais fiáveis do que as heurísticas simples de perplexidade e burstiness. Ainda assim, não existe uma combinação universalmente correta: recomenda-se testar o pipeline contra um conjunto próprio de pelo menos 50 textos humanos e 50 textos de IA antes de fixar os pesos definitivos para o seu caso de uso.

Modelo de origem	Taxa média de deteção (texto não editado)	Taxa após paráfrase humana
ChatGPT (série GPT)	~92%	Cai significativamente, chegando a ~42% em alguns testes com edições mínimas
Gemini	~87% a 89%	Sem dados consistentes de paráfrase publicados
Claude	~87%, o modelo historicamente mais difícil de detetar	Sem dados consistentes de paráfrase publicados
DeepSeek	~94%, o modelo mais fácil de detetar entre os avaliados	Sem dados consistentes de paráfrase publicados
Modelos genéricos (GPT-5) com paráfrase	87% (Originality.ai) / 76% (GPTZero) sem edição	62% (Originality.ai) / 51% (GPTZero) com paráfrase adversária

Passo 11 e 12: reduzir falsos positivos e publicar o detetor como serviço

Um estudo de 2025 sobre escrita académica em contexto STEM mostrou que combinar três detetores (GPTZero, DetectGPT e Originality.ai) e só sinalizar um texto quando pelo menos dois concordam reduz a probabilidade conjunta de um falso positivo para cerca de 0,0073%, muito abaixo da taxa de 1% a 8% típica de um único detetor isolado. Aplique a mesma lógica de “duas em três” ao seu pipeline antes de tomar qualquer decisão com consequências reais, como reprovar um trabalho ou rejeitar um artigo.

Ao publicar o serviço, pense também em limites de taxa (rate limiting) e em registo estruturado. Cada pedido processado deve deixar um registo com data, pontuação obtida por cada sinal, e o veredito final, para que uma decisão possa ser revista mais tarde. Isto é especialmente relevante se a sua organização estiver sujeita ao Artigo 50 do AI Act, onde a capacidade de justificar como uma peça de conteúdo foi avaliada pode ser pedida numa auditoria.

Por fim, exponha o detetor como um pequeno serviço web, para que outras aplicações (um sistema de gestão de conteúdos, por exemplo) possam consultá-lo:

from flask import Flask, request, jsonify

app = Flask(__name__)

@app.route("/detetar", methods=["POST"])
def endpoint_deteccao():
    dados = request.get_json()
    texto = dados.get("texto", "")
    if not texto or len(texto) < 50:
        return jsonify({"erro": "Texto demasiado curto para análise fiável"}), 400
    resultado = detetar_texto_ia(texto)
    return jsonify(resultado)

if __name__ == "__main__":
    app.run(host="0.0.0.0", port=5000)

Erros comuns a evitar

Confiar num único detetor. Como mostram as tabelas acima, cada ferramenta tem pontos cegos diferentes. Um veredito isolado nunca deve ser tratado como prova definitiva.
Ignorar o efeito da paráfrase. Um texto de IA reescrito por uma ferramenta de “humanização”, ou mesmo por uma pessoa, pode derrubar a precisão de 87% para 51-62%, como visto na tabela de deteção por modelo.
Usar detetores treinados em inglês para avaliar texto em português sem calibração. A maioria dos datasets de treino destas ferramentas é dominada por inglês, o que aumenta o risco de falsos positivos em português europeu.
Tratar o resultado como decisão automática. Sobretudo em contexto académico ou disciplinar, o resultado de um detetor deve ser um ponto de partida para revisão humana, nunca o veredito final.
Esquecer de atualizar o pipeline. Mesmo a GPTZero, que afirma otimizar continuamente o modelo para reconhecer os LLMs mais recentes, já admitiu recuos de precisão face a modelos lançados em 2026. Reveja os seus limiares a cada trimestre.
Não guardar registo das decisões. Sem um histórico de pontuações e vereditos, é impossível auditar o comportamento do detetor ao longo do tempo ou responder a um pedido de justificação.

Resolução de problemas

Estes são os problemas mais frequentes ao montar este tipo de pipeline, e como resolvê-los.

Erro 401 na API da GPTZero: a chave de API está errada, expirou ou não foi carregada da variável de ambiente. Confirme com echo $GPTZERO_API_KEY.
Erro 429 (demasiados pedidos): excedeu o limite mensal de palavras do seu plano. Reveja o consumo no painel da conta ou faça upgrade de plano.
A perplexidade local é sempre muito baixa, mesmo em texto humano: o GPT-2 é um modelo antigo e pequeno. Compare sempre contra uma baseline de textos humanos conhecidos antes de fixar limiares.
Falha na instalação do torch em Apple Silicon: instale a build específica para arm64 recomendada na documentação oficial do PyTorch, em vez da build genérica.
c2patool devolve “no claim found”: significa que o ficheiro nunca teve Content Credentials embutidas, não que a verificação falhou. Nem todas as ferramentas de geração implementam o standard.
Resultados inconsistentes entre execuções do mesmo texto: normalmente não é o detetor, mas sim variações no próprio texto de origem (por exemplo, colar com formatação invisível). Limpe o texto antes de analisar.
Texto em português é marcado como IA com frequência anómala: é um problema de viés de idioma conhecido nestas ferramentas. Aumente o peso da revisão humana para conteúdo em português.
O ensemble devolve “indeterminado” com demasiada frequência: os limiares definidos no exemplo de código (0,33 e 0,66) são um ponto de partida. Ajuste-os com base num conjunto de teste próprio antes de usar em produção.
A aplicação Flask cai com textos muito longos: defina um limite máximo de carateres no endpoint e pagine textos maiores antes de os enviar ao pipeline.
O detetor marca como “IA” um texto que sabe ser 100% humano: verifique se o texto foi escrito com apoio de um corretor gramatical avançado ou de um tradutor automático. Ambos tendem a uniformizar o estilo de forma parecida com a de um LLM, reduzindo a burstiness.
A verificação C2PA demora muito tempo ou falha em ficheiros grandes: confirme que está a usar a versão mais recente do c2patool, já que versões antigas tinham problemas de desempenho conhecidos com manifestos grandes.

Dicas avançadas para deteção de texto de IA em produção

Depois de ter o pipeline básico a funcionar, há três práticas que fazem a diferença num contexto real. Primeiro, priorize sinais de marca de água (SynthID, C2PA) sempre que estiverem disponíveis: ao contrário da perplexidade ou da burstiness, uma marca de água bem verificada não perde fiabilidade à medida que saem novos modelos, porque não depende de adivinhar um padrão estatístico. Esta corrida entre geração e deteção lembra a que já existe entre modelos e técnicas de jailbreak como o sockpuppeting: sempre que um lado avança, o outro adapta-se, e nenhuma solução técnica isolada se mantém eficaz de forma permanente.

Segundo, monitorize a precisão do seu ensemble ao longo do tempo com um pequeno conjunto de teste que atualize a cada lançamento importante de modelo (por exemplo, sempre que a Mistral, a OpenAI ou a Google anunciam uma nova geração). Terceiro, se a sua organização está sujeita ao Artigo 50 do AI Act, documente por escrito o processo de deteção e revisão humana usado: isso conta como prova de diligência em caso de auditoria, mesmo que nenhum detetor seja perfeito.

Uma quarta prática, útil para redações e equipas de moderação, é segmentar o texto por parágrafo em vez de analisar um documento inteiro de uma vez. Um artigo longo pode ter três parágrafos humanos e um parágrafo colado de uma resposta de IA, e um veredito único esconde essa mistura. Analisar parágrafo a parágrafo, como a GPTZero já faz na deteção de “documentos mistos”, aumenta a granularidade sem ferramentas adicionais.

Projeto completo: o detetor de texto de IA de ponta a ponta

Reunindo tudo o que foi construído ao longo deste tutorial, o projeto final fica organizado em três ficheiros dentro da pasta detetor-texto-ia: um módulo heuristica.py com as funções de perplexidade e burstiness, um módulo api_externa.py com a integração da GPTZero, e o ficheiro app.py com a lógica do ensemble e o endpoint Flask apresentados nos passos 9 a 12. Adicione um ficheiro requirements.txt com as quatro bibliotecas usadas (transformers, torch, flask, requests) e um ficheiro .env (fora do controlo de versões) para a chave de API.

detetor-texto-ia/
├── heuristica.py
├── api_externa.py
├── app.py
├── requirements.txt
└── .env

Para correr o projeto completo, ative o ambiente virtual, exporte a chave de API e arranque o servidor com python app.py. Teste com um pedido simples:

curl -X POST http://localhost:5000/detetar \
  -H "Content-Type: application/json" \
  -d '{"texto": "Cole aqui o texto que quer analisar, com pelo menos 50 caracteres."}'

A resposta esperada é um JSON com a pontuação combinada e o veredito, por exemplo {"pontuacao": 0.75, "veredito": "provável IA"}. A partir daqui, pode expandir o projeto adicionando um segundo endpoint que verifica Content Credentials em ficheiros anexados, ou um painel simples que guarda o histórico de análises para auditoria.

Perguntas frequentes

Um detetor de texto de IA pode ser usado como prova legal ou disciplinar?
Não deve ser usado sozinho. Dadas as taxas de falsos positivos documentadas (entre 1% e 18%, consoante a ferramenta e a população testada), qualquer decisão disciplinar ou legal precisa de revisão humana e, idealmente, de mais do que um sinal de deteção.

Qual é o modelo mais difícil de detetar em 2026?
Segundo comparações publicadas em 2026 que combinaram vários detetores, o Claude tende a ser o modelo mais difícil de identificar como IA, enquanto o DeepSeek costuma ser o mais fácil.

A paráfrase humana consegue enganar um detetor de IA?
Sim, e de forma bastante consistente. Testes de 2026 mostram quebras de precisão de 87% para 62% (Originality.ai) e de 76% para 51% (GPTZero) apenas com paráfrase adversária sobre texto do GPT-5.

A SynthID funciona em texto do ChatGPT ou só do Gemini?
A SynthID é uma tecnologia da Google DeepMind e está implementada no Gemini. A OpenAI não tem, até agosto de 2026, uma marca de água pública e verificável para texto simples do ChatGPT.

O que muda com o Artigo 50 do AI Act a partir de agosto de 2026?
Passa a ser obrigatório marcar conteúdo sintético (texto, imagem, áudio, vídeo) de forma legível por máquina, e sinalizar deepfakes e texto de IA publicado sobre assuntos de interesse público, com coimas que podem ir até 15 milhões de euros ou 3% do volume de negócios global para a maioria das infrações.

Preciso de pagar por uma ferramenta comercial para detetar texto de IA?
Não necessariamente. O detetor local construído neste tutorial, baseado em perplexidade e burstiness, é gratuito e funciona offline. Ferramentas comerciais como a GPTZero ou a Originality.ai ajudam a aumentar a precisão, mas têm custo mensal a partir de cerca de 15 USD.

Os detetores de IA funcionam bem em português europeu?
Pior do que em inglês, de um modo geral. A maioria dos conjuntos de treino destas ferramentas é dominada por texto inglês, o que aumenta o risco de falsos positivos e falsos negativos em português. Reforce sempre a revisão humana quando o texto analisado não está em inglês.

Vale a pena combinar vários detetores em vez de escolher só um?
Sim. Um estudo de 2025 em contexto académico mostrou que exigir concordância entre pelo menos dois de três detetores reduz a probabilidade conjunta de falso positivo para cerca de 0,0073%, uma melhoria clara face aos 1% a 8% típicos de um detetor isolado.

Posso usar este detetor local para textos muito curtos, como comentários ou mensagens?
Não é recomendado. Tanto a heurística de perplexidade e burstiness como a maioria das APIs comerciais perdem fiabilidade em textos com menos de 50 palavras, porque não há sinal estatístico suficiente. Para comentários curtos, a verificação de marca de água (quando disponível) é uma alternativa mais robusta do que qualquer método estatístico.

Detetar Texto de IA: 12 Passos, Até 99% de Acerto [2026]