Claix Documento a JSON API

Extracción de datos estructurados a partir de documentos de texto (.docx, .txt, .md, .rtf)

Operations 1

POST /doc-json Extrae datos estructurados de un documento de texto según un schema #

Work with this as data

Every API here is available over the APIs.io API and to AI agents over MCP.

MCP server

One button, every client — Claude, Cursor, VS Code and the rest.

https://apis.io/mcp

Tools for apis

7 MCP tools reach this
  • find_apisBrowse and filter every API in the catalog.
  • get_api_artifactsOne API's artifacts, grouped by type.
  • get_openapiThe primary OpenAPI for this API.
  • find_similar_apisAPIs that look like this one.
  • apis_io_searchSTART HERE — APIs, providers and tags for one query, each with its total.
  • resolveTurn a domain, URL or GitHub org into the provider it belongs to.
  • find_cohortsEvery scored population of providers in the catalog.
All 92 tools →

Call it yourself

curl for this page
This API
curl "https://apis.io/api/v1/apis/claix-dev:claix-dev-documento-a-json-api"
All apis
curl "https://apis.io/api/v1/apis?limit=25"

Discovery needs no key. Ratings and market analysis are Pro.

Get an API key

Free tier, no form to fill in. Signing in shares your email address with us — we store it to create your key and to recognise you if you sign in with another provider. See our Privacy Policy and Terms.

A second provider on the same verified email joins the account you already have.

OpenAPI Specification

claix-dev-documento-a-json-api-openapi.yml Raw ↑
openapi: 3.2.0
info:
  title: Claix Documento a JSON API
  description: 'Claix es una API de conversión de datos tabulares, JSON y documentos (PDF, Word, texto plano, imágenes, audio) pensada para integraciones server-to-server (backends, scripts, herramientas de automatización como n8n, Zapier o Make). Source Tracing opcional: citas por campo `{ value, source }` o `requires_human_revision` si falta evidencia. Expone seis endpoints principales de conversión:

    - **Excel/CSV → JSON**: recibe un archivo Excel o CSV y lo transforma en

    JSON según la estructura definida en un "schema" previamente creado. - **JSON → Excel**: recibe uno o varios documentos JSON y devuelve un

    archivo Excel (.xlsx) binario, según la estructura definida en un

    "schema" previamente creado. - **PDF → JSON**: recibe un archivo PDF (de texto o escaneado) y devuelve

    un objeto JSON con los datos extraídos del documento, según la

    estructura definida en un "schema" previamente creado. - **Documento → JSON**: recibe un archivo de documento (.docx, .txt, .md

    o .rtf) y devuelve un objeto JSON con los datos extraídos, según la

    estructura definida en un "schema" previamente creado. - **Imagen → JSON**: recibe una imagen (.jpeg, .jpg, .png, .webp, .heic

    o .heif) y devuelve un objeto JSON con los datos extraídos del

    contenido visible, según la estructura definida en un "schema"

    previamente creado. - **Txt / HTML / XML → JSON**: recibe el campo `content` (texto plano,

    HTML o XML ya procesado, sin archivo) y devuelve un objeto JSON con los

    datos extraídos, según un schema de tipo txt-json. Máximo 300.000

    caracteres. Tarifa fija €0,10 por llamada exitosa tras el free tier. - **Excel/CSV → Markdown**, **PDF → Markdown**, **Documento → Markdown**,

    **Imagen → Markdown**, **Txt/HTML/XML → Markdown** y **Audio → Markdown**:

    misma autenticación, mismos formatos y mismos límites que el endpoint JSON

    equivalente. No piden schema_id. save=true inserta el Markdown en la base

    conectada y la respuesta incluye row_id. PDF con texto, Excel, documentos y

    texto se convierten en local. PDF escaneado, imagen y audio llaman al

    mismo modelo con BYOK. - **Audio → JSON**: recibe un archivo de audio (.mp3, .wav, .m4a o .ogg)

    y un schema_id, y devuelve un único objeto JSON con los datos extraídos

    de lo hablado. Tamaño máximo 12 MB y duración máxima 10 minutos. Si el

    audio no es inteligible, responde 422. Además, expone endpoints para consultar y gestionar los schemas de la cuenta:

    - **Listar schemas**: dado un API key, devuelve todos los schemas de esa

    cuenta con su información completa (id, nombre, tipo y definición). - **Obtener schema**: dado un `schema_id` en la URL, devuelve ese schema

    con su definición completa. - **Crear schema**: crea un schema con `name`, `type`, `schema_definition`

    y, opcionalmente, Modo Agente (`is_agent_mode`, `agent_definition`,

    `resumen_agent`) y verificación de fuente. - **Actualizar schema**: sustituye la configuración completa de un schema

    existente (`schema_id` en la URL; mismo body que crear). - **Borrar schema**: elimina un schema de la cuenta por `schema_id`. **Ventana de Contexto** — Tras una extracción con `window_context` activo, el `document_id` devuelto permite consultar el contenido bruto, preguntar al markdown persistido o eliminar el documento:

    - **GET https://claix.dev/get-document/{document_id}**: devuelve el

    contenido bruto y metadatos del documento (`content`, `file_name`,

    `schema_id`, `processed_at`). Llamada gratuita. - **POST https://claix.dev/document-context/{document_id}**: body

    `{ "questions": [{ "question": "...", "format": "string"|"int"|"boolean"|"timestamp"|"array" }] }`

    (máximo 5 preguntas, 400 caracteres cada una). Respuesta

    `{ user_ask, ia_response, log_id }`. Cada respuesta respeta el `format`

    pedido (o `null`). Si la verificación de fuente está activada en consulta

    a documentos, cada ítem de `ia_response` es `{ value, source }`. - **DELETE https://claix.dev/delete-document/{document_id}**: elimina el

    documento persistido por `document_id`. Sin body ni query params. Respuesta `{ document_id }`.'
  version: 1.12.0
servers:
- url: https://claix.dev/api
  description: Producción (dominio público Claix)
security:
- ApiKeyAuth: []
- BearerAuth: []
tags:
- name: Documento a JSON
  description: Extracción de datos estructurados a partir de documentos de texto (.docx, .txt, .md, .rtf)
paths:
  /doc-json:
    post:
      operationId: docToJson
      tags:
      - Documento a JSON
      summary: Extrae datos estructurados de un documento de texto según un schema
      description: 'Recibe un archivo de documento (.docx, .txt, .md o .rtf) y un schema_id, y devuelve un único objeto JSON con los datos extraídos del documento completo, con las claves exactamente iguales a las propiedades definidas en el schema. El texto se extrae de forma determinista en el servidor ANTES de llamar a la IA (desempaquetado del .docx, decodificación UTF-8 para .txt/.md, stripping de códigos de control para .rtf); solo el texto plano resultante se envía al modelo. El formato legacy .doc (Word 97-2003) no está soportado. Igual que en pdf-json, el documento se trata como una única fuente de datos: la respuesta siempre contiene exactamente un registro en "data". El tamaño máximo de archivo admitido es 10 MB, y el texto extraído no puede superar los 300.000 caracteres. La respuesta incluye `log_id`. Si la verificación de fuente está activada en el schema, cada propiedad extraída es `{ value, source }`.'
      requestBody:
        required: true
        content:
          multipart/form-data:
            schema:
              $ref: '#/components/schemas/DocJsonRequest'
      responses:
        '200':
          description: Documento analizado y datos extraídos correctamente
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/DocJsonSuccessResponse'
        '400':
          description: 'Petición inválida (archivo faltante, formato no soportado, documento vacío o sin texto extraíble, .doc legacy sin convertir, .docx corrupto, o schema_id incorrecto/faltante/de tipo equivocado)

            '
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
        '401':
          description: No autorizado (API key inválida, inactiva o cuenta suspendida)
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
        '404':
          description: El schema_id no existe o no pertenece a la cuenta
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
        '405':
          description: Método HTTP no permitido (solo se admite POST)
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
        '413':
          description: 'El archivo supera el tamaño máximo admitido (10 MB), o el texto extraído supera el límite de 300.000 caracteres

            '
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
        '422':
          description: 'No se pudo extraer ningún dato del documento relacionado con el schema indicado

            '
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
        '500':
          description: Error interno del servidor
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
        '502':
          description: Fallo del servicio de IA encargado de analizar el texto
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
components:
  schemas:
    LogId:
      type:
      - string
      - 'null'
      format: uuid
      description: 'Identificador del registro en usage_logs de esta llamada. Presente en respuestas de éxito de extracción, modo agente, document-context y space-context, y en la mayoría de errores una vez autenticada la petición. Puede omitirse si el insert del log falla.

        '
      example: 7c2e1a90-4b3d-4f8a-9e21-6d5c8b0a1f34
    ErrorResponse:
      type: object
      properties:
        error:
          type: string
          description: Descripción legible del problema.
          example: No se envió el campo schema_id.
        detalle:
          type: string
          description: Información técnica adicional (solo presente en algunos casos).
          example: Missing required field 'schema_id' in multipart/form-data body.
        log_id:
          $ref: '#/components/schemas/LogId'
    DocJsonRequest:
      type: object
      required:
      - file
      - schema_id
      properties:
        file:
          type: string
          format: binary
          description: 'Archivo de documento a analizar. Formatos admitidos: .docx (application/vnd.openxmlformats-officedocument.wordprocessingml.document), .txt (text/plain), .md (text/markdown) y .rtf (application/rtf). El formato legacy .doc (application/msword) NO está soportado. Tamaño máximo admitido: 10 MB.

            '
        schema_id:
          type: string
          format: uuid
          description: 'Identificador del schema (previamente creado) de tipo "Documento a JSON".

            '
          example: b980cfe7-61ef-4a5a-9724-881c8a5541e2
        space_id:
          type: string
          format: uuid
          description: 'Opcional. Espacio de conocimiento al que se asocia el documento guardado. Debe pertenecer al mismo usuario dueño de la API key. Solo tiene efecto cuando el schema tiene la ventana de contexto activada, que es cuando el documento se guarda.

            '
          example: 5b9e2c14-7d3a-4f8b-9e1c-6a0d4b8f2e7c
    DocJsonSuccessResponse:
      type: object
      properties:
        success:
          type: boolean
          example: true
        schema_utilizado:
          type: string
          description: Nombre del schema aplicado.
          example: Contratos de Alquiler
        total_registros:
          type: integer
          description: 'Siempre 1 en este endpoint: el documento completo se trata como una única fuente de datos, no como una tabla de múltiples filas.

            '
          example: 1
        data:
          type: array
          description: 'Contiene exactamente un objeto con los datos extraídos del documento, según las propiedades definidas en el schema. Los datos no encontrados en el texto se devuelven como null. Si la verificación de fuente está activada en el schema, cada propiedad es { value, source } (source cita página, párrafo y línea).

            '
          items:
            type: object
            additionalProperties: true
          example:
          - nombre_arrendatario: Laura Fernández Ruiz
            nombre_arrendador: Inversiones Delta S.L.
            direccion_inmueble: Calle Mayor 14, 3ºB, Madrid
            renta_mensual: 950.0
            fecha_inicio: '2026-04-01'
        log_id:
          $ref: '#/components/schemas/LogId'
  securitySchemes:
    ApiKeyAuth:
      type: apiKey
      in: header
      name: x-api-key
      description: 'API key secreta de servidor. Tiene prioridad sobre Authorization si se envían ambos headers.

        '
    BearerAuth:
      type: http
      scheme: bearer
      description: Forma alternativa de enviar la API key como Bearer token.
x-provenance:
  method: harvested
  publisher: Claix
  source: https://www.claix.dev/openapi.yaml
  note: split by refine-openapis from the provider's own published document, verified by fetch (openapi/_original/*.fetch.json);
    stamped by stamp-openapi-provenance.py (roadmap#793)