Como validar CPF em plataformas de venda de ingressos para evitar cambismo

Vincular cada ingresso a um CPF validado via API é a medida mais eficaz contra o cambismo digital: impede a compra com CPFs fictícios, aplica limite por pessoa física e cria rastreabilidade completa do portador do ingresso.

Introdução

O cambismo digital é uma das maiores ameaças à experiência de compra de ingressos no Brasil. Bots e revendedores profissionais compram grandes quantidades de ingressos em segundos, esgotando eventos populares antes que o público genuíno consiga realizar a compra. Os ingressos são então revendidos a preços inflacionados, prejudicando consumidores e a reputação dos organizadores.

A vinculação do ingresso a um CPF validado é a principal arma contra essa prática.

O problema do cambismo digital

Como os cambistas operam

• Bots de compra -- Scripts automatizados que completam o checkout em frações de segundo, adquirindo centenas de ingressos antes de usuários reais.

• Múltiplas contas -- Cambistas criam dezenas de contas com dados fictícios ou de terceiros para contornar limites de compra por conta.

• CPFs aleatórios -- Utilizam geradores de CPF para preencher campos obrigatórios com números sintaticamente válidos mas que não correspondem a pessoas reais.

• Redes de revendedores -- Grupos organizados que distribuem as compras entre múltiplas contas para diluir o volume por conta.

Impacto

• Consumidores legítimos não conseguem comprar ingressos a preço de face.
• Organizadores perdem controle sobre quem participa do evento.
• Riscos de segurança quando a identidade do portador do ingresso é desconhecida.
• Danos à reputação da plataforma de venda.

Estratégia de validação de CPF para ingressos

A validação deve acontecer em duas etapas: na compra e no check-in.

Na compra

1. O comprador informa CPF e nome para cada ingresso adquirido.
2. O sistema valida cada CPF via API, confirmando existência e correspondência de nome.
3. O ingresso é vinculado ao CPF validado.
4. Limite de ingressos por CPF é aplicado.

No check-in

1. O portador apresenta o ingresso (QR code) e documento com CPF.
2. O sistema verifica se o CPF do documento corresponde ao CPF vinculado ao ingresso.
3. Se confere, a entrada é liberada.

Implementação com Node.js

const express = require('express');
const crypto = require('crypto');
const app = express();
app.use(express.json());

const CPFHUB_API_KEY = 'SUA_CHAVE_DE_API';
const LIMITE_INGRESSOS_POR_CPF = 4;

// Simulacao de banco de dados
const ingressosDb = new Map();
const comprasPorCpf = new Map();

async function validarCpf(cpf) {
    const controller = new AbortController();
    const timeoutId = setTimeout(() => controller.abort(), 10000);

    try {
    const response = await fetch(
    `https://api.cpfhub.io/cpf/${cpf}`,
    {
    method: 'GET',
    headers: {
    'x-api-key': CPFHUB_API_KEY,
    'Accept': 'application/json'
    },
    signal: controller.signal
    }
    );
    clearTimeout(timeoutId);
    return await response.json();
    } catch (error) {
    clearTimeout(timeoutId);
    throw error;
    }
}

function gerarCodigoIngresso() {
    return crypto.randomBytes(16).toString('hex').toUpperCase();
}

// Endpoint de compra de ingressos
app.post('/api/ingressos/comprar', async (req, res) => {
    const { evento_id, participantes } = req.body;
    // participantes: [{ cpf, nome }, ...]

    if (!participantes || participantes.length === 0) {
    return res.status(400).json({
    erro: 'Informe ao menos um participante'
    });
    }

    const ingressosEmitidos = [];
    const erros = [];

    for (const participante of participantes) {
    const { cpf, nome } = participante;

    // Verificar limite por CPF
    const comprasExistentes = comprasPorCpf.get(cpf) || 0;
    if (comprasExistentes >= LIMITE_INGRESSOS_POR_CPF) {
    erros.push({
    cpf,
    erro: `Limite de ${LIMITE_INGRESSOS_POR_CPF} ingressos `
    + `por CPF atingido`
    });
    continue;
    }

    // Validar CPF via API
    try {
    const resultado = await validarCpf(cpf);

    if (!resultado.success) {
    erros.push({ cpf, erro: 'CPF nao encontrado na base' });
    continue;
    }

    // Verificar correspondencia de nome
    const nomeApi = resultado.data.nameUpper;
    const nomeInformado = nome.toUpperCase().trim();
    const palavrasApi = nomeApi.split(' ');
    const palavrasInformadas = nomeInformado.split(' ');

    const coincidencias = palavrasInformadas.filter(
    p => palavrasApi.includes(p)
    ).length;

    const taxa = coincidencias / Math.max(
    palavrasApi.length,
    palavrasInformadas.length
    );

    if (taxa < 0.5) {
    erros.push({
    cpf,
    erro: 'Nome informado nao corresponde ao CPF'
    });
    continue;
    }

    // Emitir ingresso
    const codigo = gerarCodigoIngresso();
    const ingresso = {
    codigo,
    evento_id,
    cpf: resultado.data.cpf,
    nome_titular: resultado.data.name,
    data_nascimento: resultado.data.birthDate,
    status: 'ATIVO',
    checkin: false,
    emitido_em: new Date().toISOString()
    };

    ingressosDb.set(codigo, ingresso);
    comprasPorCpf.set(cpf, comprasExistentes + 1);
    ingressosEmitidos.push({
    codigo,
    titular: resultado.data.name
    });
    } catch (error) {
    erros.push({ cpf, erro: 'Falha na validacao do CPF' });
    }
    }

    return res.json({
    ingressos_emitidos: ingressosEmitidos,
    erros,
    total_emitidos: ingressosEmitidos.length
    });
});

// Endpoint de check-in
app.post('/api/ingressos/checkin', async (req, res) => {
    const { codigo, cpf_documento } = req.body;

    const ingresso = ingressosDb.get(codigo);

    if (!ingresso) {
    return res.status(404).json({ erro: 'Ingresso nao encontrado' });
    }

    if (ingresso.checkin) {
    return res.status(400).json({ erro: 'Ingresso ja utilizado' });
    }

    if (ingresso.cpf !== cpf_documento) {
    return res.status(403).json({
    erro: 'CPF do documento nao corresponde ao titular do ingresso'
    });
    }

    ingresso.checkin = true;
    ingresso.checkin_em = new Date().toISOString();

    return res.json({
    sucesso: true,
    titular: ingresso.nome_titular,
    evento: ingresso.evento_id
    });
});

app.listen(3000);

Medidas anti-bot complementares

A validação de CPF é a camada principal, mas deve ser complementada com outras medidas:

• Rate limiting -- Limitar o número de tentativas de compra por IP e por sessão.

• CAPTCHA -- Adicionar desafios que diferenciem humanos de bots no checkout.

• Fila virtual -- Distribuir o acesso à página de compra de forma controlada em eventos de alta demanda.

• Delay entre compras -- Impor um intervalo mínimo entre compras do mesmo IP ou dispositivo.

• Fingerprint de dispositivo -- Identificar quando múltiplas contas operam a partir do mesmo dispositivo.

Transferência segura de ingressos

Para permitir que compradores transfiram ingressos legitimamente (caso não possam comparecer), implemente um fluxo de transferência que também valide o CPF do destinatário:

1. O titular original solicita a transferência informando o CPF do destinatário.
2. O sistema valida o CPF do destinatário via API.
3. O ingresso é revinculado ao novo CPF.
4. O titular original perde o acesso ao ingresso.

Isso permite flexibilidade sem abrir brechas para o cambismo, pois cada transferência é rastreada e vinculada a CPFs reais.

Legislação brasileira sobre cambismo

A Lei 12.868/2013 e legislações estaduais tipificam o cambismo como contravenção penal. Plataformas de venda de ingressos que implementam validação de CPF demonstram diligência no combate a essa prática, fortalecendo sua posição legal e a confiança dos organizadores de eventos.

A validação de CPF também auxilia na emissão de notas fiscais, já que o CPF do comprador é necessário para a documentação fiscal correta da transação.

Perguntas frequentes

Como a validação de CPF impede bots de comprar ingressos?

Bots utilizam CPFs gerados algoritmicamente — números sintaticamente válidos mas que não correspondem a pessoas reais. A validação via API confirma a existência do CPF na base de dados oficial e verifica a correspondência com o nome informado. CPFs fictícios falham nessa verificação e têm a compra bloqueada automaticamente.

Quantos ingressos por CPF é razoável permitir?

A prática do mercado varia entre 2 e 6 ingressos por CPF por evento. Para shows muito disputados, 2 é o limite mais seguro. O importante é que o limite seja aplicado sobre o CPF validado — não sobre a conta — o que impede que cambistas criem múltiplas contas para contornar a restrição.

A API CPFHub.io suporta o volume de pico em vendas de ingressos?

Sim. A CPFHub.io não bloqueia requisições ao atingir o limite do plano — cobra R$0,15 por consulta adicional, garantindo que nenhuma venda seja interrompida por cota esgotada. O plano Pro inclui 1.000 consultas mensais por R$149 e suporta picos de demanda sem configuração adicional.

Como lidar com transferência legítima de ingressos sem abrir brecha para cambismo?

Implemente um fluxo de transferência que valide o CPF do destinatário via API antes de revincular o ingresso. Registre cada transferência com CPF de origem e destino, data e hora. Limite o número de transferências permitidas por ingresso para evitar que o mecanismo seja usado como canal de revenda disfarçada.

Conclusão

O cambismo digital pode ser significativamente reduzido com a implementação de validação de CPF em todas as etapas da jornada do ingresso: compra, transferência e check-in. Ao vincular cada ingresso a um CPF validado e limitar a quantidade por pessoa física, a plataforma protege os consumidores legítimos e os organizadores de eventos.

Cadastre-se em cpfhub.io — 50 consultas mensais gratuitas, sem cartão de crédito — e implemente a validação de CPF no seu checkout de ingressos ainda hoje.