> ## Documentation Index
> Fetch the complete documentation index at: https://docs.dokstamp.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Operações em Lote

> Emita certificados e reenvie requisições de assinatura em lote para turmas grandes de formandos.

# Operações em Lote

Para turmas grandes — centenas ou milhares de formandos — a API oferece endpoints e padrões de lote para minimizar o número de requisições e reduzir o tempo de processamento.

***

## Exclusão em lote

A maioria dos recursos suporta exclusão em lote via `DELETE /recurso/batch/destroy` com um corpo contendo UUIDs:

```bash theme={null}
curl -X DELETE https://api.dokstamp.com/certificates/batch/destroy \
  -H "Authorization: Bearer {TOKEN}" \
  -H "Accept: application/json" \
  -H "Content-Type: application/json" \
  -H "X-Tenant: {TENANT}" \
  -d '{ "uuids": ["uuid-1", "uuid-2", "uuid-3"] }'
```

***

## Emissão de certificados em lote (padrão)

Não existe um endpoint único de "criar certificados em lote" — cada certificado requer seu próprio arquivo exclusivo. No entanto, você pode otimizar o processo com um pipeline eficiente:

### 1. Enviar todos os arquivos em uma única requisição

```bash theme={null}
curl -X POST https://api.dokstamp.com/files \
  -H "Authorization: Bearer {TOKEN}" \
  -H "Accept: application/json" \
  -H "X-Tenant: {TENANT}" \
  -F "files[]=@diploma-1.pdf" \
  -F "files[]=@diploma-2.pdf" \
  -F "files[]=@diploma-3.pdf"
```

A resposta inclui um array de objetos de arquivo. Mapeie cada arquivo para um estudante pelo nome do arquivo ou índice.

### 2. Emitir certificados de forma concorrente

Use requisições HTTP concorrentes (Promise.all em JavaScript, cURL paralelo, pool do Guzzle em PHP):

```javascript JavaScript theme={null}
const issuances = students.map((student, index) => ({
  institution_uuid: INSTITUTION_UUID,
  course_uuid: COURSE_UUID,
  student_uuid: student.uuid,
  file_uuid: files[index].uuid,
  status: 'issued',
  issued_at: new Date().toISOString(),
}));

const results = await Promise.all(
  issuances.map(payload =>
    fetch('https://api.dokstamp.com/certificates', {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${TOKEN}`,
        'Accept': 'application/json',
        'Content-Type': 'application/json',
        'X-Tenant': TENANT,
      },
      body: JSON.stringify(payload),
    }).then(r => r.json())
  )
);

const verificationUrls = results.map(r => r.data.public_verification_url);
```

```php PHP (Guzzle pool) theme={null}
use GuzzleHttp\Client;
use GuzzleHttp\Pool;
use GuzzleHttp\Psr7\Request;

$client = new Client(['base_uri' => 'https://api.dokstamp.com']);
$headers = [
    'Authorization' => "Bearer $token",
    'Accept'        => 'application/json',
    'Content-Type'  => 'application/json',
    'X-Tenant'      => $tenant,
];

$requests = function () use ($students, $files, $headers) {
    foreach ($students as $i => $student) {
        $body = json_encode([
            'institution_uuid' => INSTITUTION_UUID,
            'course_uuid'      => COURSE_UUID,
            'student_uuid'     => $student['uuid'],
            'file_uuid'        => $files[$i]['uuid'],
            'status'           => 'issued',
            'issued_at'        => now()->toIso8601String(),
        ]);
        yield new Request('POST', 'certificates', $headers, $body);
    }
};

$pool = new Pool($client, $requests(), ['concurrency' => 10]);
$pool->promise()->wait();
```

***

## Reenvio de requisições de assinatura em lote

Para fluxos de assinatura de documentos, reenvie e-mails de solicitação de assinatura para múltiplos signatários de uma vez:

```http theme={null}
POST /documents/signatures/batch/resend
```

```bash theme={null}
curl -X POST https://api.dokstamp.com/documents/signatures/batch/resend \
  -H "Authorization: Bearer {TOKEN}" \
  -H "Accept: application/json" \
  -H "Content-Type: application/json" \
  -H "X-Tenant: {TENANT}" \
  -d '{
    "document_ids": [101, 102, 103]
  }'
```

***

## Assinatura institucional em lote

Assine múltiplos documentos de uma vez com o certificado digital institucional:

```http theme={null}
POST /documents/batch/sign/{cert_id}
```

```bash theme={null}
curl -X POST "https://api.dokstamp.com/documents/batch/sign/1" \
  -H "Authorization: Bearer {TOKEN}" \
  -H "Accept: application/json" \
  -H "Content-Type: application/json" \
  -H "X-Tenant: {TENANT}" \
  -d '{
    "document_ids": [101, 102, 103],
    "pin": "123456"
  }'
```

***

## Paginação para grandes conjuntos de resultados

Ao buscar listas grandes (ex.: todos os estudantes para identificar certificados ausentes), use paginação:

```bash theme={null}
# Buscar todas as matrículas concluídas em páginas de 200
PAGE=1
while true; do
  RESPONSE=$(curl -s "$API/enrollments?where[completion_status]=completed&per_page=200&page=$PAGE" \
    -H "Authorization: Bearer $TOKEN" \
    -H "Accept: application/json" \
    -H "X-Tenant: $TENANT")
  
  TOTAL_PAGES=$(echo $RESPONSE | jq -r '.meta.last_page')
  echo "Processando página $PAGE de $TOTAL_PAGES"
  
  # Processar itens...
  
  [ "$PAGE" -ge "$TOTAL_PAGES" ] && break
  PAGE=$((PAGE + 1))
done
```