Documentação da API

Documentação da API DoDocs Matchpoint

Guia completo para integrar a API de processamento de documentos DoDocs Matchpoint em suas aplicações. Extraia dados de faturas, recibos e documentos com simples chamadas à API REST.

Começar Agora

Visão Geral da API

A API DoDocs Matchpoint oferece acesso programático às nossas capacidades de processamento de documentos, permitindo que você extraia dados estruturados de diversos tipos de documentos.

Tipos de Documentos

Processe faturas, recibos, extratos bancários, contratos e muito mais.

Processamento em Tempo Real

Receba resultados via webhooks ou respostas síncronas.

Seguro e Confiável

Segurança de nível empresarial com SLA de 99,9% de disponibilidade.

URLs Base

Ambiente	URL Base	Finalidade
URL da API	`https://api.dodocs.ai`	Ambiente de produção ativo
Painel	`https://dodocs.ai`	Painel web para gerenciamento de chaves de API

Primeiros Passos

Passo 1: Crie Sua Conta

Cadastre-se para uma conta DoDocs Matchpoint em workspace para começar.

Passo 2: Acesse Seu Painel

Após fazer login, você verá seu painel principal, onde pode gerenciar documentos e chaves de API.

O painel DoDocs Matchpoint mostrando seus documentos processados

Passo 3: Gere uma Chave de API

Navegue até a seção Chaves de API na barra lateral para criar e gerenciar suas chaves de API.

A página de gerenciamento de Chaves de API

Clique em "Criar Chave de API" para gerar uma nova chave:

Importante: Sua chave de API será exibida apenas uma vez. Copie-a e armazene-a com segurança imediatamente após a criação.

Passo 4: Teste Sua Chave de API

Verifique se sua chave de API está funcionando com este teste simples:

curl -X GET https://api.dodocs.ai/api/v1/health \
  -H "DoDocs-Matchpoint-API-Key: your_api_key_here"

Resposta esperada:

{
  "status": "healthy",
  "timestamp": "2024-01-27T10:30:00Z"
}

Autenticação

Todas as requisições à API devem incluir sua chave de API no cabeçalho DoDocs-Matchpoint-API-Key :

DoDocs-Matchpoint-API-Key: your_api_key_here

Formato da Chave de API

Comprimento: Tipicamente 40–50 caracteres
Diferencia maiúsculas/minúsculas: As chaves devem ser usadas exatamente como fornecidas

Boas Práticas de Segurança

Faça:

Armazene chaves de API em variáveis de ambiente
Use chaves diferentes para desenvolvimento e produção
Alterne as chaves regularmente (a cada 90 dias é recomendado)
Use HTTPS em todas as chamadas à API

Não faça:

Incluir chaves de API no controle de versão
Incluir chaves em código do lado do cliente
Compartilhar chaves entre aplicações
Usar chaves em parâmetros de URL

Fazendo Chamadas à API

Endpoint de Upload de Documentos

POST/api/v1/upload

Envie documentos para processamento usando multipart/form-data.

Parâmetros da Requisição

Parâmetro	Tipo	Obrigatório	Descrição
`metadata`	String JSON	Sim	MUST be first field in request. DEVE ser o primeiro campo na requisição. Instruções de processamento e configuração (pode estar vazio: {})
`file`	Arquivo	Sim	O arquivo de documento a ser processado

Important: O campo de metadados deve ser sempre o primeiro campo na requisição multipart. A ordem importa — adicione os metadados primeiro, depois o arquivo.

Opções de Metadados

{
  "clientReference": "ORDER-123",  // Optional: Your reference ID
  "urgent": true,                  // Optional: Priority processing
  "language": "en"                 // Optional: Document language
}

// Or can be empty:
{}

Requisitos de Arquivo

Formato	Extensões	Tamanho Máximo
PDF	.pdf	50 MB
Images	.jpg, .jpeg, .png, .tiff	25 MB
Word	.doc, .docx	25 MB
Excel	.xls, .xlsx	25 MB
Text	.txt, .csv	10 MB

Configuração de Webhooks

Webhooks permitem que você receba notificações em tempo real quando seus documentos são processados.

Configurando Webhooks

Configure webhooks pelas configurações da chave de API no seu painel.

Interface de configuração de webhook

Eventos de Webhook

`document.processed`

Enviado quando o processamento do documento é concluído com sucesso.

{
  "requestId": "75193012-0885-4db7-b5ce-7506e169c80c",
  "documentData": "[{\"fileName\":\"Transaction_Summary.xls\",\"documentType\":\"Bank Statement\"}]",
  "errors": []
}

`document.failed`

Enviado quando o processamento do documento falha.

{
  "requestId": "8b6683c7-e583-4fbc-aa23-5bf1d22d32eb",
  "documentData": "[]",
  "errors": [
    {
      "code": "EXTRACTION_FAILED",
      "message": "Unable to extract data from document",
      "details": "Poor image quality or unsupported format"
    }
  ]
}

Cabeçalhos de Webhook

Cada requisição de webhook inclui estes cabeçalhos:

X-Webhook-Signature: sha256=abc123...
X-Webhook-Event: document.processed
X-Webhook-ID: unique-webhook-id
X-Webhook-Timestamp: 1706354400
Content-Type: application/json

Verificação de Assinatura

Sempre verifique as assinaturas de webhook para garantir que elas vêm do DoDocs Matchpoint.

Python

import hmac
import hashlib

def verify_webhook(payload, signature, secret):
    expected_signature = hmac.new(
        secret.encode('utf-8'),
        payload.encode('utf-8'),
        hashlib.sha256
    ).hexdigest()

    expected = f"sha256={expected_signature}"
    return hmac.compare_digest(signature, expected)

Node.js

const crypto = require('crypto');

function verifyWebhook(payload, signature, secret) {
  const expectedSignature = crypto
    .createHmac('sha256', secret)
    .update(payload)
    .digest('hex');

  const expected = `sha256=${expectedSignature}`;

  return crypto.timingSafeEqual(
    Buffer.from(signature),
    Buffer.from(expected)
  );
}

Exemplos de Código

Python — Enviar Documento

import requests
import json

url = "https://api.dodocs.ai/api/v1/upload"
api_key = "your_api_key_here"

# Prepare metadata (must come first in the request)
metadata = {'clientReference': 'INV-2024-001'}
data = {'metadata': json.dumps(metadata)}

# Prepare the file
files = {
    'file': ('invoice.pdf', open('invoice.pdf', 'rb'), 'application/pdf')
}

# Make the request
response = requests.post(
    url,
    headers={'DoDocs-Matchpoint-API-Key': api_key},
    data=data,
    files=files
)
print(response.json())

Python — Tratar Webhook

from flask import Flask, request

app = Flask(__name__)

@app.route('/webhook', methods=['POST'])
def handle_webhook():
    event = request.json
    if event['event'] == 'document.processed':
        handle_processed(event['data'])
    elif event['event'] == 'document.failed':
        handle_failed(event['data'])
    return '', 200

def handle_processed(data):
    print(f"Document processed: {data['extractedData']}")

def handle_failed(data):
    print(f"Processing failed: {data['errorMessage']}")

if __name__ == '__main__':
    app.run(port=3000)

Node.js — Enviar Documento

const FormData = require('form-data');
const fs = require('fs');
const axios = require('axios');

const form = new FormData();
// Metadata must come first
form.append('metadata', JSON.stringify({ clientReference: 'INV-2024-001' }));
form.append('file', fs.createReadStream('invoice.pdf'));

axios.post('https://api.dodocs.ai/api/v1/upload', form, {
  headers: {
    'DoDocs-Matchpoint-API-Key': 'your_api_key_here',
    ...form.getHeaders()
  }
})
.then(response => console.log(response.data))
.catch(error => console.error(error));

cURL — Enviar Documento

curl -X POST https://api.dodocs.ai/api/v1/upload \
  -H "DoDocs-Matchpoint-API-Key: your_api_key_here" \
  -F 'metadata={"clientReference":"INV-2024-001"}' \
  -F "[email protected]"

cURL — Testar Webhook

# Use webhook.site for testing
# 1. Go to https://webhook.site
# 2. Copy your unique URL
# 3. Configure it in your DoDocs Matchpoint dashboard

# Or use ngrok for local testing:
npm install -g ngrok
ngrok http 3000

Suporte e Recursos

Documentação

Você está visualizando nossa documentação completa da API.

Voltar ao Topo

Suporte por E-mail

Obtenha ajuda da nossa equipe de suporte técnico.

Contatar Suporte

Precisa de Suporte Empresarial?

Para suporte empresarial com garantias de SLA, gerenciamento de conta dedicado e suporte prioritário:

Contatar Vendas