---
source_url: "https://dynadok.com/en/document-validation-api/"
title: "Document Validation API: Documentation and Integrations"
generated_at: 2026-10-10T01:20:03Z
host: dynadok.com
type: page
schema_types: [WebPage]
generator: geostack/1.0.0
---
## Structured data
```json
{
"@context": "https://schema.org",
"@graph": [
{
"@type": "WebPage",
"@id": "https://dynadok.com/en/document-validation-api/#webpage",
"url": "https://dynadok.com/en/document-validation-api/",
"headline": "Document Validation API: Documentation and Integrations",
"datePublished": "2026-09-29T03:51:54+00:00",
"dateModified": "2026-09-29T03:51:56+00:00",
"inLanguage": "pt-BR",
"publisher": {
"@type": "Organization",
"name": "Dynadok",
"url": "https://dynadok.com/"
},
"description": "Dynadok can be used through the platform, through the API, or both. For your engineering team, here is what matters: it takes two endpoints to get document validation running — a POST that sends the file and a GET that returns the extracted data. API-key authentication, plain HTTP requests, JSON responses. Updated September 2026 · […]"
}
]
}
```
# Document Validation API: Documentation and Integrations
Dynadok can be used through the platform, through the API, or both. For your engineering team, here is what matters: it takes **two endpoints** to get document validation running — a `POST` that sends the file and a `GET` that returns the extracted data. API-key authentication, plain HTTP requests, JSON responses.
Updated September 2026 · Dynadok Team Direct answerThe Dynadok API has the base URL **https://api.dynadok.com** and authenticates through the **x-api-key** header. You send the document to `POST /v1/api/documents`, receive an `id` with a processing status and fetch the result from `GET /v1/api/documents/{id}`. No need to replace your ERP, HRIS, LMS or student information system: Dynadok integrates with the environment you already have.
[Open the documentation](https://doc.dynadok.com/docs/intro) [See the endpoints](https://doc.dynadok.com/docs/API/endpoints)
First integration## From zero to your first validated document
Three steps. Any HTTP client will do: cURL, Postman or your language’s standard library.
01### Get your API key
Authentication uses the `x-api-key` header with the key provided by Dynadok. Requests without a key, or with an invalid or expired key, return `401 Unauthorized`.
Base URL ```
https://api.dynadok.com
```
02### Send the document
A multipart `POST` with the file in `files` and the document type in `type`. The response returns the `id` and the processing status.
cURL ```
curl --location 'https://api.dynadok.com/v1/api/documents' \
--header 'x-api-key: your_api_key' \
--form 'files=@"/path/to/file.pdf"' \
--form 'type="RG"'
```
Response ```
{
"id": "123456",
"status": "processing"
}
```
03### Retrieve the extracted data
With the `id` in hand, query the processed document. The response returns the status and the fields extracted by the AI.
cURL ```
curl -X GET "https://api.dynadok.com/v1/api/documents/{id}" \
--header 'x-api-key: your_api_key'
```
Response ```
{
"id": "123456",
"status": "processed",
"data": {
"nome": "John Smith",
"documento": "123456789",
"data_emissao": "2023-01-01"
}
}
```
Same thing, in your language## Python example
Nothing exotic: an HTTP request with `requests`. The same applies to axios or fetch in JavaScript and HttpClient in Java or C#.
```
import requests
url = 'https://api.dynadok.com/v1/api/documents'
payload = {'type': 'CERTIDAO_DE_NASCIMENTO'}
files = [
('files', ('file_name.pdf', open('file_name.pdf', 'rb'), 'application/pdf'))
]
headers = {
'x-api-key': '••••••'
}
response = requests.request("POST", url, headers=headers, data=payload, files=files)
print(response.text)
```
Reference## Endpoints
MethodRouteDescription `POST` `/v1/api/documents` Sends a document (image or PDF) for processing. Returns the `id` and the initial status. `GET` `/v1/api/documents/{id}` Returns the information extracted from an already processed document.
The full reference, with headers, parameters and up-to-date examples, lives in the technical documentation: [doc.dynadok.com](https://doc.dynadok.com/docs/API/endpoints). Workflows, rules and integrations specific to your project are defined in the implementation scope.
The type parameter## Examples of document types
Each type has its own description and return interface in the documentation. The catalog grew out of Brazilian projects and keeps evolving: document types for your country and your process — national IDs, driver’s licenses, passports, proof of address, payslips, tax filings, transcripts, corporate registrations — are configured within the implementation scope.
National ID cardRG
Driver’s licenseCNH
Individual taxpayer IDCPF
Proof of addressCOMPROVANTE\_RESIDENCIA
Employment recordCARTEIRA\_DE\_TRABALHO
Marriage certificateCERTIDAO\_DE\_CASAMENTO
Birth certificateCERTIDAO\_DE\_NASCIMENTO
High school diplomaCERTIFICADO\_CONCLUSAO\_ENSINO\_MEDIO
Corporate registration statusCOMPROVANTE\_DE\_INSCRICAO\_E\_DE\_SITUACAO\_CADASTRAL
Articles of incorporationCONTRATO\_SOCIAL
Personal income tax returnDECLARACAO\_IMPOSTO\_RENDA\_PESSOA\_FISICA\_IRPF
Academic transcriptHISTORICO\_ESCOLAR
PayslipHOLERITE
Financial-aid application formPROUNI\_FICHA\_INSCRICAO
Withholding tax receiptRECIBO\_IRRF
Taxpayer registration statusSITUACAO\_CADASTRAL\_CPF
Beyond extraction## Validation rules
The documentation describes the rules that apply to document acceptance. Each rule has properties that define how the document must be validated and accepted — that is what lets the analysis adapt to each operation’s process.
- **Driver’s license category** `CNH_CATEGORY`
- **Company registration status** `CNPJ_REGISTRATION_STATUS`
- **Company size** `COMPANY_SIZE`
- **Reference period** `COMPETENCY`
- **Taxpayer ID status** `CPF_STATUS`
- **Issue date** `EMISSION_DATE`
- **Expiration date** `EXPIRATION_DATE`
- **Location** `LOCATION`
- **Opening date** `OPENING_DATE`
- **Ownership** `OWNERSHIP`
- **Start of activities** `START_OF_ACTIVITIES`
- **Transcript level and status** `STATUS_DEGREE_HISTORICO_ESCOLAR`
- **Substitute documents** `SUBSTITUTE_DOCUMENTS`
Rules such as **expiration date**, **ownership** and **substitute documents** are what turn data extraction into real validation: reading the field is not enough, you have to decide whether that document is acceptable for that process, at that moment and for that person.
Three ways to use it## Platform, API, or both
01### Platform only
Teams work in the Dynadok interface, with configured checklists and workflows. Third parties and applicants upload documents straight to the platform and get a non-compliance notification within seconds.
02### API only
Validation happens inside your own systems: you send documents via HTTP request and receive the extracted data and the rule results, without the end user ever leaving your environment.
03### Platform + API
Submission and analysis run through the API, while the operations team uses the platform to handle exceptions, monitor queues and audit what was decided.
**No need to replace your ERP or core systems.** Dynadok adapts to your current environment and integrates with existing systems, keeping your workflow intact. Platform and API access is included in the contract, within the project scope, with no per-user or per-license charge.
Response handling## Most common error codes
CodeCommon causeWhat to do `400` Bad RequestMalformed data or missing required parametersCheck the request structure and parameters against the documentation `401` UnauthorizedAPI key missing, invalid or expiredMake sure the key is correct and included in the header `403` ForbiddenAPI key lacks the required permissionsCheck that the key is allowed to access the requested resource `404` Not FoundWrong endpoint URL or non-existent resourceConfirm the route and that the resource exists `405` Method Not AllowedWrong HTTP method for the resourceUse the method specified in the documentation `429` Too Many RequestsToo many requests in a short periodImplement retries with exponential backoff `500` / `502` / `503` / `504`Internal error, bad gateway, temporary unavailability or timeoutRetry the request later and, if it persists, contact support
What your team needs## Integration requirements
Nothing beyond what already exists in any stack that consumes a REST API.
- **API key** provided by Dynadok, sent in the `x-api-key` header
- **HTTP client:** cURL, Postman or your language’s library
- **Python:** `requests`
- **JavaScript:** `axios` or `fetch`
- **Java and C#:** `HttpClient`
- **Format:** multipart file upload and JSON response
### Security in the integration
All traffic between customer systems, browsers and the Dynadok platform is protected with **TLS 1.2 or higher**. Documents and extracted data are stored encrypted with **AES-256**, with logical segregation between customers and audit trails for access, download and export.
Treat the API key as a credential: keep it out of your repository and front end, and prefer environment variables or a secrets vault.
Frequently asked questions## Questions from the people who will integrate
Where is Dynadok’s technical documentation?At doc.dynadok.com. The documentation covers API integration, supported document types with their return interfaces, validation rules, usage examples and handling of the most common errors.
How does authentication work?Through an API key sent in the `x-api-key` header, provided by Dynadok. Requests without a key, or with an invalid or expired key, return `401 Unauthorized`; a key without permission for the resource returns `403 Forbidden`.
Which file formats can I send?The upload endpoint accepts images or PDFs. The AI processes structured, semi-structured, unstructured and even handwritten documents, with advanced OCR and computer vision, including scans and long files.
Is processing synchronous?No. The upload immediately returns an `id` with status `processing`, and the result is retrieved later from `GET /v1/api/documents/{id}`, which returns status `processed` and the extracted data. In practice, validation takes seconds.
What if my document is not in the list of types?The types shown here are only examples, and the documented list evolves with each project. New document types, rules and workflows — including documents specific to your country or industry — are assessed and configured within the implementation scope. Additions after the original scope may require a new technical and commercial assessment.
Are validation rules configurable?Yes. Each rule has properties that define how the document must be validated and accepted — issue and expiration dates, ownership, location, registration status, substitute documents and more. Checklists are built per document type and per process, with your operation’s criteria.
Do I need to replace the system I already use?No. Dynadok adapts to your current environment and integrates with existing systems, keeping your workflow intact. You can use only the API, only the platform, or both models combined.
Does API usage cost extra?There is no additional charge per user, seat or license: platform and API access is included in the contract, within the project scope. The recurring cost is determined by the volume of pages processed by the AI. See the [pricing and billing model](https://dynadok.com/en/pricing/) for details.
How do I reach technical support during the integration?Support channels are listed in the documentation itself, at doc.dynadok.com. During implementation, the Dynadok project team follows the development of the in-scope integrations, testing, acceptance and go-live.