Claix is an AI document intelligence API that converts unstructured files into schema-based JSON and provides queryable document context for AI agents. It processes PDFs, Excel spreadsheets, Word documents, images, and text using multimodal vision models, allowing developers to extract structured data and query documents on demand.

Which file formats can I convert to structured JSON?

Claix natively supports PDF (.pdf), Excel workbooks (.xlsx, .xls), Word documents (.docx, .doc), images (.png, .jpg, .jpeg, .webp), and plain text files (.txt, .html, .md). Each format is processed with visual document understanding to return typed, validated JSON conforming to your custom schema.

How do I convert Excel spreadsheets to JSON with the API?

To convert an Excel file, send a POST request to /api/excel-json with your file and target JSON schema. Claix interprets multi-sheet workbooks, merged headers, and relational tables, returning clean JSON ready for ingestion.

Can I convert PDFs, Word documents, and images to JSON?

Yes. Claix provides dedicated endpoints for each format: /api/pdf-json for complex or scanned PDFs, /api/doc-json for Word files, and /api/img-json for images and receipts. Every endpoint uses visual intelligence to interpret layout structures and output valid JSON.

Who is Claix built for?

Claix is designed for software developers, AI agent builders, SaaS engineering teams, and automation specialists using platforms like n8n or Make. It eliminates the need to build custom OCR, chunking, and vector retrieval pipelines.

What is the Claix pricing model?

Claix operates on a pay-per-use model per processed document (from 0.10 € for images to 0.15 € for complex PDFs) and 0.03 € per follow-up question. There are no mandatory monthly subscriptions for standard extraction, and new accounts include 100 free successful processing runs.

Are failed requests charged to my account?

No. Claix only charges for successful HTTP 200 processing requests that return valid extracted data. Failed API calls due to invalid parameters or system errors do not consume your quota or balance.

What is Claix Agent Mode?

Claix Agent Mode (/agent/*-json) is an extraction mode where an AI agent interprets ambiguous documents using natural language instructions instead of a rigid schema, allowing dynamic extraction based on context.

What is the difference between normal extraction and Agent Mode?

Normal extraction enforces strict, deterministic schema conformance for predictable pipelines. Agent Mode allows natural language reasoning over document contents, ideal for unstructured contracts and variable layouts.

How do I ask follow-up questions to a single document?

When you process a document with context enabled, Claix returns a document_id. You can send questions to POST /document-context/{document_id} to query that specific file without re-uploading or reprocessing.

What is the temporary context window?

The context window is a temporary retention layer that keeps a processed document queryable for follow-up questions without permanent storage, enabling multi-turn agent interactions before expiring automatically.

What are Knowledge Spaces, and how do I query multiple documents at once?

Knowledge Spaces allow you to group multiple persistent documents under a single space_id. By sending questions to POST /space-context/{space_id}, your AI agent can query, compare, calculate totals, and cross-reference data across all active documents in that space simultaneously.

Can I white-label Claix or integrate it into automated workflows?

Yes. Claix is fully headless and integrates server-to-server via API keys, making it compatible with custom SaaS backends and automation platforms like n8n or Make.

Context Window · Create space

Create a knowledge space

Endpoint

POSThttps://claix.dev/create-space

A knowledge space is a logical folder for grouping persisted documents. This endpoint creates the empty space and returns its space_id, the piece that ties the whole flow together: group on extraction, ask the whole group, and delete it when you no longer need it.

The only input field is name. There is nothing else to configure: a space has no schema, no expiry, and no settings of its own.

Public URL: POST https://claix.dev/create-space. Never expose the direct Supabase URL.

This call is free: it is not billed and does not consume your extraction or context-window quota.

1. Authentication

Every request must include your API key. It is a personal server-side credential, different from any user session token.

Option A — Dedicated header (recommended):

x-api-key: <YOUR_API_KEY>

Option B — Standard Authorization header:

Authorization: Bearer <YOUR_API_KEY>

Either one is enough. If you send both, x-api-key wins.

Claix checks that the key exists and is active, and that the account is not suspended. Otherwise it returns 401. The space belongs to the account that owns the key, so only that account can use or delete it later.

2. Request format

Method: POST · Content-Type: application/json

Field	Type	Required	Description
name	string	Yes	Space name, for example “Suppliers 2026”. Max 200 characters. Leading and trailing whitespace is trimmed.

Example body:

{
  "name": "Proveedores 2026"
}

Duplicate names are allowed: every call creates a new space with its own space_id. If you need unique names, check for them on your side before calling.

3. Building the call

Send POST to https://claix.dev/create-space with your API key and a JSON body containing name.
Store the space_id from the response in your database: you need it for the next two steps.
When extracting with any of the five extraction endpoints (or their Agent versions), add space_id as an optional field so the saved document lands inside the space. Remember that a document is only saved when the schema has the context window enabled.
Ask the whole group with POST /space-context/{space_id}.

4. Request examples

Use the code panel on the right to copy examples in cURL, JavaScript, Python, and more.

5. Success response format

HTTP 201 — Space created. The response returns the identifier, the stored name, and the creation timestamp.

{
  "success": true,
  "space": {
    "space_id": "5b9e2c14-7d3a-4f8b-9e1c-6a0d4b8f2e7c",
    "name": "Proveedores 2026",
    "created_at": "2026-09-05T14:32:11.482Z"
  }
}

Field	Type	Description
success	boolean	Always true in a 201 response.
space.space_id	string (uuid)	Space identifier. This is the value you send as space_id when extracting, and the one that goes in the space-context and delete-space URLs.
space.name	string	Stored name, already trimmed of surrounding whitespace.
space.created_at	string (ISO 8601)	Date and time the space was created.

6. Error codes

{
  "error": "Descripción legible del problema.",
  "detalle": "Información técnica adicional (solo presente en algunos casos)."
}

400 — The body is not a JSON object, or name is missing, empty, or longer than 200 characters.

401 — Authentication failed: key missing, unknown, disabled, or account not active.

405 — Method other than POST. · 500 — Internal error.

7. Code summary

Code	Category	Retry?
201	Success — space created	—
400	Client error (name missing, empty, or too long)	No — fix the request first
401	Authentication error	No — fix credentials first
405	Incorrect HTTP method	No — use POST
500	Internal server error	Yes, with caution

8. Best practices

Create the space once and reuse its space_id; do not create one on every extraction.
Use one space per real unit of work (a client, a case file, a quarter) rather than one giant space: cross-document answers get more precise the tighter the group is.
Give spaces descriptive names — the name is all you have to identify them.
Always use the public claix.dev domain, not the direct Supabase URL.
Never ship your API key in frontend code or public repositories.