Code Examples

Complete, copy-paste-ready examples for common API workflows.

Python — Extract and Process Documents

import requests
import json
import time
import os

API_KEY = os.environ["QOMPLEMENT_API_KEY"]
BASE_URL = "https://developer-api.qomplement.com/v1"
HEADERS = {"Authorization": f"Bearer {API_KEY}"}


def extract_document(file_path, schema=None, model=None):
    """Extract structured data from a document."""
    with open(file_path, "rb") as f:
        files = {"file": f}
        data = {}
        if schema:
            data["schema"] = json.dumps(schema)
        if model:
            data["model"] = model

        response = requests.post(
            f"{BASE_URL}/extract",
            headers=HEADERS,
            files=files,
            data=data,
        )

    response.raise_for_status()
    result = response.json()

    if result["status"] == "completed":
        return result["result"]
    else:
        return wait_for_job(result["id"])


def wait_for_job(job_id, interval=3, timeout=300):
    """Poll a job until completion."""
    elapsed = 0
    while elapsed < timeout:
        resp = requests.get(f"{BASE_URL}/jobs/{job_id}", headers=HEADERS)
        job = resp.json()

        if job["status"] == "completed":
            return job["result"]
        elif job["status"] == "failed":
            raise Exception(f"Job failed: {job['error']['message']}")

        time.sleep(interval)
        elapsed += interval

    raise TimeoutError("Job timed out")


# Extract invoice data
result = extract_document("invoice.pdf")
print(f"Type: {result['document_type']}, Language: {result['language']}")
for key, value in result["fields"].items():
    print(f"  {key}: {value}")

# Extract with specific schema
schema = [
    {"name": "invoice_number", "type": "string"},
    {"name": "vendor_name", "type": "string"},
    {"name": "total", "type": "number"},
    {"name": "date", "type": "date"},
]
result = extract_document("invoice.pdf", schema=schema)
print(f"Invoice #{result['fields'].get('invoice_number')}")
print(f"Total: ${result['fields'].get('total')}")

Python — Extract + OpenAI Integration

Extract document data with qomplement and analyze it with OpenAI.

import requests
import json
import os
from openai import OpenAI

# API clients
QOMPLEMENT_KEY = os.environ["QOMPLEMENT_API_KEY"]
BASE_URL = "https://developer-api.qomplement.com/v1"
HEADERS = {"Authorization": f"Bearer {QOMPLEMENT_KEY}"}

openai_client = OpenAI()  # Uses OPENAI_API_KEY env var


def extract_document(file_path):
    """Extract data from a document using qomplement."""
    with open(file_path, "rb") as f:
        response = requests.post(
            f"{BASE_URL}/extract",
            headers=HEADERS,
            files={"file": f},
            data={"detail": "true"},
        )
    response.raise_for_status()
    result = response.json()

    if result["status"] == "completed":
        return result["result"]

    # Poll for async result
    import time
    job_id = result["id"]
    for _ in range(100):
        resp = requests.get(f"{BASE_URL}/jobs/{job_id}", headers=HEADERS).json()
        if resp["status"] == "completed":
            return resp["result"]
        if resp["status"] == "failed":
            raise Exception(resp["error"]["message"])
        time.sleep(3)


def analyze_with_openai(extraction, prompt):
    """Send extracted data to OpenAI for analysis."""
    response = openai_client.chat.completions.create(
        model="gpt-4o-mini",
        messages=[
            {
                "role": "system",
                "content": "You are a document analysis assistant. Analyze the extracted document data and answer the user's question.",
            },
            {
                "role": "user",
                "content": f"Here is the extracted document data:\n\n"
                           f"Document type: {extraction['document_type']}\n"
                           f"Fields: {json.dumps(extraction['fields'], indent=2)}\n"
                           f"Tables: {json.dumps(extraction.get('tables', []), indent=2)}\n\n"
                           f"Question: {prompt}",
            },
        ],
    )
    return response.choices[0].message.content


# --- Example 1: Invoice Analysis ---
extraction = extract_document("invoice.pdf")
print("Extracted fields:", json.dumps(extraction["fields"], indent=2))

analysis = analyze_with_openai(
    extraction,
    "Summarize this invoice. What is the total amount, who is it from, "
    "and are there any line items that seem unusually expensive?"
)
print("\nAI Analysis:\n", analysis)


# --- Example 2: Contract Review ---
extraction = extract_document("contract.pdf")

review = analyze_with_openai(
    extraction,
    "Review this contract. What are the key terms, obligations, "
    "and any clauses I should pay special attention to?"
)
print("\nContract Review:\n", review)


# --- Example 3: Receipt Categorization ---
receipts = ["receipt1.jpg", "receipt2.jpg", "receipt3.jpg"]
all_extractions = []

for receipt in receipts:
    ext = extract_document(receipt)
    all_extractions.append(ext["fields"])

response = openai_client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[
        {
            "role": "system",
            "content": "You are an expense categorization assistant.",
        },
        {
            "role": "user",
            "content": f"Categorize these receipts by expense type "
                       f"(food, transport, office, etc.) and calculate the total:\n\n"
                       f"{json.dumps(all_extractions, indent=2)}",
        },
    ],
)
print("\nExpense Report:\n", response.choices[0].message.content)

JavaScript — Extract + OpenAI Integration

const fs = require("fs");
const path = require("path");
const OpenAI = require("openai");

const QOMPLEMENT_KEY = process.env.QOMPLEMENT_API_KEY;
const BASE_URL = "https://developer-api.qomplement.com/v1";

const openai = new OpenAI(); // Uses OPENAI_API_KEY env var

async function extractDocument(filePath) {
  const form = new FormData();
  form.append("file", new Blob([fs.readFileSync(filePath)]), path.basename(filePath));
  form.append("detail", "true");

  const response = await fetch(`${BASE_URL}/extract`, {
    method: "POST",
    headers: { Authorization: `Bearer ${QOMPLEMENT_KEY}` },
    body: form,
  });

  const data = await response.json();
  if (data.status === "completed") return data.result;

  // Poll for async result
  const jobId = data.id;
  for (let i = 0; i < 100; i++) {
    const resp = await fetch(`${BASE_URL}/jobs/${jobId}`, {
      headers: { Authorization: `Bearer ${QOMPLEMENT_KEY}` },
    });
    const job = await resp.json();
    if (job.status === "completed") return job.result;
    if (job.status === "failed") throw new Error(job.error.message);
    await new Promise((r) => setTimeout(r, 3000));
  }
}

async function analyzeWithOpenAI(extraction, prompt) {
  const response = await openai.chat.completions.create({
    model: "gpt-4o-mini",
    messages: [
      {
        role: "system",
        content: "You are a document analysis assistant. Analyze the extracted document data and answer the user's question.",
      },
      {
        role: "user",
        content: `Here is the extracted document data:\n\n` +
          `Document type: ${extraction.document_type}\n` +
          `Fields: ${JSON.stringify(extraction.fields, null, 2)}\n` +
          `Tables: ${JSON.stringify(extraction.tables || [], null, 2)}\n\n` +
          `Question: ${prompt}`,
      },
    ],
  });
  return response.choices[0].message.content;
}

(async () => {
  // Extract and analyze an invoice
  const extraction = await extractDocument("invoice.pdf");
  console.log("Extracted fields:", extraction.fields);

  const analysis = await analyzeWithOpenAI(
    extraction,
    "Summarize this invoice. What is the total, who is the vendor, and list all line items."
  );
  console.log("\nAI Analysis:\n", analysis);
})();

Node.js — Full Workflow (Extract, Fill PDF, Fill Excel)

const fs = require("fs");
const path = require("path");

const API_KEY = process.env.QOMPLEMENT_API_KEY;
const BASE_URL = "https://developer-api.qomplement.com/v1";

async function apiRequest(endpoint, formData) {
  const response = await fetch(`${BASE_URL}${endpoint}`, {
    method: "POST",
    headers: { Authorization: `Bearer ${API_KEY}` },
    body: formData,
  });
  if (!response.ok) throw new Error(`HTTP ${response.status}: ${await response.text()}`);
  return response.json();
}

async function waitForJob(jobId) {
  for (let i = 0; i < 100; i++) {
    const resp = await fetch(`${BASE_URL}/jobs/${jobId}`, {
      headers: { Authorization: `Bearer ${API_KEY}` },
    });
    const job = await resp.json();
    if (job.status === "completed") return job;
    if (job.status === "failed") throw new Error(job.error.message);
    if (job.progress) {
      console.log(`  ${job.progress.message}`);
    }
    await new Promise((r) => setTimeout(r, 3000));
  }
  throw new Error("Timeout");
}

async function downloadFile(jobId, outputPath) {
  const resp = await fetch(`${BASE_URL}/jobs/${jobId}/download`, {
    headers: { Authorization: `Bearer ${API_KEY}` },
  });
  fs.writeFileSync(outputPath, Buffer.from(await resp.arrayBuffer()));
  console.log(`  Downloaded: ${outputPath}`);
}

(async () => {
  // 1. Extract data from invoice
  console.log("1. Extracting data from invoice...");
  const extractForm = new FormData();
  extractForm.append("file", new Blob([fs.readFileSync("invoice.pdf")]), "invoice.pdf");

  const extractResult = await apiRequest("/extract", extractForm);
  const extraction = extractResult.status === "completed"
    ? extractResult.result
    : (await waitForJob(extractResult.id)).result;

  console.log("  Fields:", extraction.fields);
  console.log("  Tables:", extraction.tables?.length || 0, "found");

  // 2. Fill a PDF form with the extracted data
  console.log("\n2. Filling PDF form...");
  const pdfForm = new FormData();
  pdfForm.append("source_files", new Blob([fs.readFileSync("invoice.pdf")]), "invoice.pdf");
  pdfForm.append("target_pdf", new Blob([fs.readFileSync("form.pdf")]), "form.pdf");

  const pdfJob = await apiRequest("/fill/pdf", pdfForm);
  const pdfResult = await waitForJob(pdfJob.id);
  console.log(`  Filled ${pdfResult.result.fields_filled}/${pdfResult.result.fields_total} fields`);
  await downloadFile(pdfResult.id, "filled_form.pdf");

  // 3. Fill an Excel template
  console.log("\n3. Filling Excel template...");
  const excelForm = new FormData();
  excelForm.append("source_files", new Blob([fs.readFileSync("invoice.pdf")]), "invoice.pdf");
  excelForm.append("target_excel", new Blob([fs.readFileSync("template.xlsx")]), "template.xlsx");
  excelForm.append("fill_mode", "smart");

  const excelJob = await apiRequest("/fill/excel", excelForm);
  const excelResult = await waitForJob(excelJob.id);
  console.log(`  Wrote ${excelResult.result.cells_written} cells`);
  await downloadFile(excelResult.id, "filled_report.xlsx");

  console.log("\nDone!");
})();

Python — Batch Processing with Webhooks

import requests
import json
import os
from flask import Flask, request, jsonify

API_KEY = os.environ["QOMPLEMENT_API_KEY"]
BASE_URL = "https://developer-api.qomplement.com/v1"
HEADERS = {"Authorization": f"Bearer {API_KEY}"}
WEBHOOK_URL = "https://your-server.com/api/webhooks/qomplement"

app = Flask(__name__)


def submit_extraction(file_path):
    """Submit a document for async extraction with webhook."""
    with open(file_path, "rb") as f:
        response = requests.post(
            f"{BASE_URL}/extract",
            headers=HEADERS,
            files={"file": f},
            data={"webhook_url": WEBHOOK_URL},
        )
    response.raise_for_status()
    job = response.json()
    print(f"Submitted {file_path} → Job {job['id']}")
    return job["id"]


@app.route("/api/webhooks/qomplement", methods=["POST"])
def handle_webhook():
    """Receive extraction results via webhook."""
    payload = request.json
    job_id = payload["job_id"]
    data = payload["data"]

    if data["status"] == "completed":
        result = data["result"]
        print(f"Job {job_id} completed:")
        print(f"  Type: {result['document_type']}")
        print(f"  Fields: {result['fields']}")

        # Save results to database, trigger downstream processing, etc.
    else:
        print(f"Job {job_id} failed: {data['error']['message']}")

    return jsonify({"received": True}), 200


# Submit a batch of documents
if __name__ == "__main__":
    documents = ["invoice1.pdf", "invoice2.pdf", "receipt1.jpg", "contract.pdf"]
    for doc in documents:
        submit_extraction(doc)

    # Start webhook server to receive results
    app.run(port=5000)

cURL — All Endpoints Quick Reference

# Set your API key
export QOMPLEMENT_API_KEY="sd_your_key_here"

# --- Extract ---
# Basic extraction
curl -X POST https://developer-api.qomplement.com/v1/extract \
  -H "Authorization: Bearer $QOMPLEMENT_API_KEY" \
  -F "file=@invoice.pdf"

# Extract with schema
curl -X POST https://developer-api.qomplement.com/v1/extract \
  -H "Authorization: Bearer $QOMPLEMENT_API_KEY" \
  -F "file=@invoice.pdf" \
  -F 'schema=[{"name":"total","type":"number"},{"name":"date","type":"date"}]'

# Extract with high precision model
curl -X POST https://developer-api.qomplement.com/v1/extract \
  -H "Authorization: Bearer $QOMPLEMENT_API_KEY" \
  -F "file=@complex_table.pdf" \
  -F "model=qomplement-OCR-XL-v1"

# Extract with detail mode
curl -X POST https://developer-api.qomplement.com/v1/extract \
  -H "Authorization: Bearer $QOMPLEMENT_API_KEY" \
  -F "file=@contract.pdf" \
  -F "detail=true"

# --- Fill PDF ---
curl -X POST https://developer-api.qomplement.com/v1/fill/pdf \
  -H "Authorization: Bearer $QOMPLEMENT_API_KEY" \
  -F "source_files=@data_source.pdf" \
  -F "target_pdf=@form.pdf"

# Fill PDF with explicit field mappings
curl -X POST https://developer-api.qomplement.com/v1/fill/pdf \
  -H "Authorization: Bearer $QOMPLEMENT_API_KEY" \
  -F "target_pdf=@form.pdf" \
  -F 'field_mappings={"first_name":"John","last_name":"Smith"}'

# --- Fill Excel ---
curl -X POST https://developer-api.qomplement.com/v1/fill/excel \
  -H "Authorization: Bearer $QOMPLEMENT_API_KEY" \
  -F "source_files=@invoice.pdf" \
  -F "target_excel=@template.xlsx" \
  -F "fill_mode=smart"

# --- Jobs ---
# Check job status
curl https://developer-api.qomplement.com/v1/jobs/JOB_ID \
  -H "Authorization: Bearer $QOMPLEMENT_API_KEY"

# List jobs
curl "https://developer-api.qomplement.com/v1/jobs?status=completed&limit=10" \
  -H "Authorization: Bearer $QOMPLEMENT_API_KEY"

# Download filled file
curl -o output_file \
  "https://developer-api.qomplement.com/v1/jobs/JOB_ID/download" \
  -H "Authorization: Bearer $QOMPLEMENT_API_KEY"

# --- Usage ---
curl https://developer-api.qomplement.com/v1/usage \
  -H "Authorization: Bearer $QOMPLEMENT_API_KEY"

# --- Models ---
curl https://developer-api.qomplement.com/v1/models \
  -H "Authorization: Bearer $QOMPLEMENT_API_KEY"

# --- Health ---
curl https://developer-api.qomplement.com/v1/health

Go — Extract Document

package main

import (
	"bytes"
	"encoding/json"
	"fmt"
	"io"
	"mime/multipart"
	"net/http"
	"os"
	"time"
)

const baseURL = "https://developer-api.qomplement.com/v1"

func extract(filePath, apiKey string) (map[string]interface{}, error) {
	body := &bytes.Buffer{}
	writer := multipart.NewWriter(body)

	file, err := os.Open(filePath)
	if err != nil {
		return nil, err
	}
	defer file.Close()

	part, _ := writer.CreateFormFile("file", filePath)
	io.Copy(part, file)
	writer.Close()

	req, _ := http.NewRequest("POST", baseURL+"/extract", body)
	req.Header.Set("Authorization", "Bearer "+apiKey)
	req.Header.Set("Content-Type", writer.FormDataContentType())

	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		return nil, err
	}
	defer resp.Body.Close()

	var result map[string]interface{}
	json.NewDecoder(resp.Body).Decode(&result)

	if result["status"] == "completed" {
		return result["result"].(map[string]interface{}), nil
	}

	// Async — poll
	jobID := result["id"].(string)
	for i := 0; i < 100; i++ {
		req, _ := http.NewRequest("GET", baseURL+"/jobs/"+jobID, nil)
		req.Header.Set("Authorization", "Bearer "+apiKey)

		resp, _ := http.DefaultClient.Do(req)
		var job map[string]interface{}
		json.NewDecoder(resp.Body).Decode(&job)
		resp.Body.Close()

		if job["status"] == "completed" {
			return job["result"].(map[string]interface{}), nil
		}
		if job["status"] == "failed" {
			return nil, fmt.Errorf("failed: %v", job["error"])
		}
		time.Sleep(3 * time.Second)
	}
	return nil, fmt.Errorf("timeout")
}

func main() {
	apiKey := os.Getenv("QOMPLEMENT_API_KEY")
	result, err := extract("invoice.pdf", apiKey)
	if err != nil {
		fmt.Println("Error:", err)
		return
	}
	fmt.Println("Type:", result["document_type"])
	fields, _ := json.MarshalIndent(result["fields"], "", "  ")
	fmt.Println("Fields:", string(fields))
}