← Voltar aos guias
InsightFace ServerAPI RESTSDK PythonReconhecimento facialRTSP

Integrar a API REST do Server

Integre o InsightFace Server via API REST e SDK Python: crie Collections, registe pessoas, execute pesquisas 1:N exatas e adicione monitorização RTSP.

16 min de leitura
Tela Collections do InsightFace Server com bancos isolados de identidades faciais
Cada Collection fixa o contrato de modelo, detecção, limiar e busca exata.

O que você vai construir

O InsightFace Server é um serviço auto-hospedado de análise e reconhecimento facial. A Web UI, a API REST /v1 versionada e o SDK Python leve operam sobre as mesmas Collections, Pessoas, FaceSamples e Monitors de câmera persistentes.

Este guia percorre uma integração completa a partir da fronteira da API: verificar autenticação e prontidão, criar uma Collection, cadastrar e buscar uma Pessoa, chamar Detect e Compare sem estado e conectar um Monitor RTSP. Também cobre os limites de repetição, dados biométricos, licença de modelos e rede necessários fora de um ambiente isolado de avaliação.

Antes de começar

  • Um servidor CPU ativo em http://127.0.0.1:18097 ou o endereço configurado de um servidor CUDA; o exemplo CUDA fornecido usa a porta 18098.
  • Imagens JPEG, PNG ou WebP obtidas com consentimento e contendo um rosto nítido; o limite padrão da imagem comprimida é 10 MiB.
  • A API key se a autenticação estiver ativada, um shell com curl e Python 3 para o fluxo opcional do SDK.
  • Um pacote de modelos licenciado e verificado. Modelos públicos pré-treinados do InsightFace limitam-se a pesquisa não comercial sem uma licença comercial separada.

1. Confirmar autenticação e contrato de resposta

Chame primeiro GET /v1/health. Esse endpoint é sempre público e informa readiness e auth_enabled. Quando auth_enabled é true, todos os demais endpoints exigem Authorization: Bearer <api_key>. Com a autenticação desativada, omita completamente o header Authorization; não envie um header vazio. O primeiro bloco mostra exatamente a forma sem autenticação, e o segundo é para deployments autenticados.

A API usa JSON snake_case e multipart/form-data para imagens. Toda resposta contém um header UUID x-request-id, repetido como request_id nos bodies JSON. Sinais de detection e qualidade usam 0.0–1.0, mas recognition similarity é o cosseno bruto em [-1.0, 1.0], não uma probabilidade. threshold aceita o intervalo inclusivo [0.0, 1.0], tem padrão 0.4 e há correspondência quando similarity >= threshold.

  • Um DELETE bem-sucedido retorna HTTP 204 sem body.
  • Nenhum rosto pode ser um resultado Detect vazio válido; nenhuma correspondência em Search retorna validamente matches: [].
  • OpenAPI está em /openapi.json e o viewer interativo same-origin, em /docs.
Autenticação desativada: omitir Authorization por completo
BASE_URL=http://127.0.0.1:18097
curl -fsS "${BASE_URL}/v1/health"
curl -sS "${BASE_URL}/v1/system"
Autenticação ativada: enviar token Bearer
export INSIGHTFACE_API_KEY='replace-with-a-long-random-secret'
BASE_URL=http://127.0.0.1:18097
AUTH_HEADER="Authorization: Bearer ${INSIGHTFACE_API_KEY}"

curl -fsS "${BASE_URL}/v1/health"
curl -sS "${BASE_URL}/v1/system" -H "${AUTH_HEADER}"

2. Criar uma Collection e fixar o contrato

Uma Collection é um banco isolado de identidades e também um contrato de deployment. Na criação, fixa model ID, version, bundle digest, embedding dimension, preprocessing version, detection profile e exact-search profile ativos. A embedding_contract_id retornada é opaca: copie-a para trusted external enrollment e nunca a construa.

Comece com threshold 0.4 e calibre-o em dados de validação representativos. Respostas da Collection expõem detection_revision e configurações efetivas de busca. Alterações posteriores no detection profile valem para novas requests, sem reextrair FaceSamples existentes. Os perfis fazem busca plana exaustiva; precisões menores aproximam o cosseno FP32, mas não são índices ANN.

  • O perfil geral padrão é fp32_v1; fp16_v1 é exclusivo de CUDA e BF16 depende de CPU compatível ou CUDA SM80+.
  • A capacidade padrão é 100.000 linhas ativas e max_faces_per_person é 20; dimensione pelo orçamento real de memória e retenção.
  • O armazenamento de face crops vem desativado. Se ativado, guarda bounding-box crops JPEG 112×112, não uploads originais nem aligned recognition inputs.
Criar a Collection employees
curl -sS "${BASE_URL}/v1/collections" -H "${AUTH_HEADER}" \
  -H 'Content-Type: application/json' \
  -d '{"id":"employees","name":"Employees","threshold":0.4}'

3. Cadastrar uma Pessoa e depois buscar

O cadastro usa multipart e aceita várias imagens numa request. review_mode=off segue a seleção facial da Collection; standard exige exatamente um rosto utilizável e aplica verificações configuradas de tamanho, confiança, qualidade e pose; strict acrescenta comparação de similaridade dentro e fora da pessoa. Um lote pode ter sucesso parcial com HTTP 201, então examine faces e rejected_images.

Search seleciona um query face com o perfil da Collection, compara com todo FaceSample ativo e atribui a cada Pessoa sua maior pontuação de amostra. Só resultados no ou acima do threshold efetivo são retornados, em similarity decrescente. Valide com uma imagem diferente das usadas no cadastro.

  • Sem query face utilizável, a resposta é 422 face_not_found; uma consulta válida sem identidade no limiar retorna matches: [].
  • Amostras aceitas são commit em SQLite e adicionadas ao índice ativo em memória antes da resposta de sucesso.
  • external_trusted ainda exige imagem pareada e embedding_contract_id exata; vetores devem ser finitos, não nulos, ter dimensão correta e norma L2 em 1.0 ± 0.0002.
Cadastrar Alice com duas imagens
curl -sS "${BASE_URL}/v1/collections/employees/persons" \
  -H "${AUTH_HEADER}" \
  -F 'id=employee-001' \
  -F 'name=Alice' \
  -F 'external_id=HR-1001' \
  -F 'metadata={"department":"sales"}' \
  -F 'review_mode=standard' \
  -F 'images=@alice1.jpg' \
  -F 'images=@alice2.jpg'
Buscar com outra imagem
curl -sS "${BASE_URL}/v1/collections/employees/search" \
  -H "${AUTH_HEADER}" \
  -F 'image=@alice-query.jpg' \
  -F 'limit=5'

4. Usar Detect e Compare sem estado

Detect retorna todos os rostos utilizáveis por área decrescente, com caixas em pixel e normalizadas, cinco landmarks, confiança do detector e sinais locais de qualidade. Não retorna embeddings nem persiste dados. Passe collection_id para usar o detection profile da Collection em vez do perfil imutável do sistema.

Compare seleciona um rosto de source e target, calcula a similarity de cosseno bruta e retorna matched segundo o threshold efetivo. Similarity pode ser negativa e nunca deve ser exibida como percentual de confiança. Se uma imagem não tiver rosto utilizável, retorna 422 face_not_found.

  • max_faces aceita 1–100. JPEG, PNG e WebP são suportados; a orientação EXIF é aplicada antes da inferência.
  • O limite padrão é 64 MiB para a request completa e 40 milhões de pixels após decodificação.
  • Detect, Compare, cadastro, Search, embeddings e reconhecimento RTSP compartilham o orçamento global de concorrência de inferência.
Detectar rostos sem persistência
curl -sS "${BASE_URL}/v1/detect" \
  -H "${AUTH_HEADER}" \
  -F 'image=@group.jpg' \
  -F 'max_faces=10' \
  -F 'collection_id=employees'
Comparar dois rostos selecionados
curl -sS "${BASE_URL}/v1/compare" \
  -H "${AUTH_HEADER}" \
  -F 'source=@source.jpg' \
  -F 'target=@target.jpg' \
  -F 'threshold=0.4'

5. Usar o SDK Python leve

Instale o client diretamente deste checkout. Ele usa httpx, não contém inference runtime e aceita caminhos, bytes ou objetos binários semelhantes a arquivo. O timeout padrão de 65 segundos é ligeiramente maior que o deadline de 60 segundos do Server.

O exemplo usa o endereço CPU do User Guide na porta 18097 e um Server autenticado. Se a autenticação estiver desativada, construa Client("http://localhost:18097") sem api_key para não enviar Authorization header. O mesmo client também oferece create_monitor, update_monitor, monitor_state e monitor_events com cursor.

  • Mantenha o timeout do client maior que o request timeout do Server, salvo se a aplicação quiser falhar antes.
  • Passe collection= a Detect ou Compare quando precisar do detection profile de uma Collection.
  • Feche o client ou use-o como context manager para liberar as conexões do pool.
Instalar o SDK Python local
python -m pip install ./server/sdk/python
Criar, cadastrar, detectar, comparar e buscar com Python
from insightface_server import Client

# Authenticated deployment. When authentication is disabled, omit api_key:
# with Client("http://localhost:18097") as client:
with Client("http://localhost:18097", api_key="your-key") as client:
    client.create_collection(
        collection_id="employees",
        name="Employees",
        threshold=0.4,
    )
    client.add_person(
        "employees",
        person_id="employee-001",
        name="Alice",
        images=["alice1.jpg", "alice2.jpg"],
        review_mode="standard",
    )

    faces = client.detect("group.jpg", max_faces=10, collection="employees")
    comparison = client.compare(
        "source.jpg", "target.jpg", threshold=0.4, collection="employees"
    )
    matches = client.search("employees", "alice-query.jpg", limit=5)

    print(faces.faces)
    print(comparison.similarity, comparison.matched)
    print(matches.matches)

6. Tratar erros e tentativas sem duplicar gravações biométricas

Erros usam um envelope JSON único com error.code, error.message, details opcionais e request_id. Mapeamentos comuns: 400 parâmetros inválidos, 401 key ausente/inválida, 404 recurso ausente, 409 conflito de estado/modelo, 413 limite de tamanho, 422 imagem inválida ou rosto inutilizável, 500 erro inesperado e 503 timeout ou runtime/índice indisponível.

GET pode ser repetido com segurança. Repita 429 e 503 transitórios com exponential backoff limitado e jitter; um 4xx de validação exige alterar a request. Após falha de transporte, a criação de Person/FaceSample é ambígua: leia primeiro o ID fornecido pelo client. Se um 503 de cadastro trouxer write_committed: true, a gravação já está em SQLite. Não repita às cegas; leia a Pessoa antes de decidir.

  • Registre x-request-id, endpoint, status e tempos seguros; nunca imagens, embeddings, API keys ou credenciais RTSP.
  • Só repita DELETE após consultar o estado atual.
  • Reutilize cursors opacos sem alteração com o mesmo endpoint e filtros; nunca os analise ou fabrique.

7. Adicionar um Monitor RTSP persistente

Tela de monitoramento de câmeras do InsightFace Server com tarefa RTSP persistente
Um Monitor RTSP persistente continua no servidor mesmo com o navegador fechado.

Um Monitor é uma tarefa server-side de reconhecimento RTSP cuja configuração fica em SQLite. Uma tarefa enabled retoma após reiniciar o Server e continua ao fechar o navegador. O decoder preserva apenas o frame mais novo; inferência lenta reduz a frequência efetiva em vez de acumular atraso. match_threshold: null herda o threshold da Collection.

A preview fica deliberadamente desativada por padrão e o reconhecimento independe dela. Quando habilitada, /preview.mjpeg transmite frames JPEG brutos sem anotação; o client desenha caixas com /state. Nunca coloque a API key na URL de preview. Consulte /events com seu cursor opaco para eventos enter, exit, error e recovery e trate truncated e stream_reset explicitamente.

  • Credenciais RTSP são criptografadas com AES-GCM em /data e a API só retorna uma origem redigida.
  • Frames de vídeo nunca são salvos. Eventos recentes vivem apenas num ring de memória limitado e se perdem ao reiniciar o processo.
  • Restrinja a administração dos Monitors a operadores confiáveis; a primeira fase tem uma API key única sem papéis, não autorização por tenant.
monitor.json
{
  "id": "front-gate",
  "name": "Front gate",
  "description": "Main entrance",
  "enabled": true,
  "source": {
    "type": "rtsp",
    "url": "rtsp://viewer:secret@camera.example/live"
  },
  "collection_id": "employees",
  "inference_fps": 2.0,
  "match_threshold": null,
  "event_buffer_size": 1000,
  "event_policy": {
    "confirm_frames": 3,
    "absence_timeout_seconds": 3.0,
    "cooldown_seconds": 10.0,
    "emit_unknown": true
  },
  "preview_enabled": false
}
Criar Monitor e consultar estado e eventos
curl -sS "${BASE_URL}/v1/monitors" -H "${AUTH_HEADER}" \
  -H 'Content-Type: application/json' \
  -d @monitor.json

curl -sS "${BASE_URL}/v1/monitors/front-gate/state" \
  -H "${AUTH_HEADER}"

curl -sS "${BASE_URL}/v1/monitors/front-gate/events?limit=100" \
  -H "${AUTH_HEADER}"

8. Proteger dados, rede, backups e direitos dos modelos

Persista /data, monte /models como somente leitura e faça backup do SQLite junto do crop storage configurado com gravações paradas ou snapshot seguro para SQLite. Trate volume e cópias como dados biométricos. Termine HTTPS num reverse proxy confiável, permita apenas origins CORS necessários e aplique limites de taxa, body e tempo na borda. Nunca exponha uma avaliação sem autenticação.

O código-fonte do Server e o SDK Python usam MIT; os modelos estão expressamente fora dessa licença. A imagem do container não contém modelos. O instalador mostra a model license e verify confere identidade do pacote, licença assinada, validade e autorização. Pacotes públicos InsightFace, inclusive buffalo_l, normalmente se limitam a pesquisa acadêmica não comercial sem uma licença comercial separada.

  • API keys são armazenadas como hashes; alterar INSIGHTFACE_API_KEY num início posterior gira intencionalmente a key ativa do volume.
  • Use docker compose down sem -v; -v remove permanentemente o named data volume.
  • Defina consentimento, retenção, exclusão, resposta a incidentes e usos autorizados antes de processar identidades reais.
Instalar e verificar pacote de modelo licenciado
docker compose -f server/deploy/compose.cpu.yml \
  run --rm models install buffalo_l --accept-license
docker compose -f server/deploy/compose.cpu.yml \
  run --rm models verify buffalo_l

Precisa de ajuda com implantação em produção?

Fale com a InsightFace sobre licenciamento de modelos, otimização de runtime e suporte para o hardware alvo.

Enviar consulta corporativa