Enterprise Substrate

Welcome to the Calera Labs Enterprise Integration portal. The Volumetric Lattice Network (VLN) provides a mathematically rigorous, zero-hallucination query interface tailored for capital markets compliance, auditing, and SEC filing validation.

Unlike probabilistic Large Language Models (LLMs), the VLN executes query decomposition deterministically, referencing Hebbian reinforcement patterns to resolve queries directly against XBRL taxonomies. If a query cannot be verified to 100% confidence, the network returns an honest failure/silence rather than inventing or guessing an answer.

Step 1: Account Creation & PQC Key Generation

To maintain the highest level of security, all client interactions are authenticated using post-quantum cryptography (PQC) hybrid schemes.

1. Navigate to the Calera Labs Portal.
2. Click Sign In / Sign Up to launch the Firebase Authentication flow.
3. Once authenticated with your corporate identity, the dashboard will prompt you to initialize your Post-Quantum Cryptography (PQC) keypair.
4. The frontend utilizes our WebAssembly signature library to generate an ML-DSA-65 keypair directly within your browser.
5. The public key is registered with the Calera Key Vault, while your private key is securely stored in your local browser's IndexedDB.

Subscription & License Credentials

All machine-to-machine integrations require plan activation and an Ed25519-signed license key.

Step 2: Subscription Activation

Different plan tiers grant access to distinct endpoints and query limits. Enterprise and High-Volume features require a Startup, Starter, Professional, or Enterprise subscription.

1. From the dashboard, navigate to the Plans tab.
2. Select the plan that matches your volume and query requirements.
3. Click the subscription button to open the secure Stripe Checkout portal.
4. Fill in your billing details and complete the transaction. Upon completion, Stripe webhooks will automatically promote your account tier and issue your API license credentials.

Step 3: API License Key Retrieval

Direct machine-to-machine integrations bypass browser sessions and authenticate using Ed25519-signed license keys.

1. Once your subscription is active, navigate to the Reference tab in your dashboard.
2. Under the API License Key section, click the visibility toggle to show your raw license key (prefixed with calera_lk_).
3. Copy this key and store it securely in your application environment variables (e.g., as X_LICENSE_KEY).

Single-Query API

Allows executing a single natural language question against historical SEC filings. Response times typically range from 150ms to 400ms.

Step 4: Execute Your First Query

Authenticate your request by sending your credentials in the X-License-Key header.

Request Headers

X-License-Key: <YOUR_LICENSE_KEY>
Content-Type: application/json

Request Body

{
  "query": "What is Apple's FY2023 revenue?"
}

Response Example

{
  "query_id": "q_9a87d6f5e4",
  "status": "VERIFIED_SUCCESS",
  "source": "Apple Inc. 10-K (FY2023)",
  "answer": {
    "value": 383285000000,
    "unit": "USD",
    "formatted": "$383.29B"
  },
  "confidence_score": 1.0,
  "provenance": {
    "entity_id": "CIK0000320193",
    "source_filing": "0000320193-23-000106",
    "company": "Apple Inc.",
    "xbrl_concept": "us-gaap:RevenueFromContractWithCustomerExcludingAssessedTax",
    "doc_period": "FY2023",
    "audit_hash": "a8f7c9e54d3c2b1a..."
  }
}

Batch-Query API

For high-volume clients, we support asynchronous queue-based batch execution. Clients submit a list of questions, receive a batch job ID, and poll the status endpoint until completion.

Step 5: Batch Query Integration (Pro/Enterprise only)

Submit up to 100 queries in a single request. The server returns a status code 202 (Accepted) and registers your job.

Request Body

{
  "queries": [
    "What is Apple's FY2023 revenue?",
    "What is Microsoft's FY2023 net income?"
  ]
}

Response (202 Accepted)

{
  "batch_id": "batch_abc123xyz789",
  "status": "PENDING",
  "total_queries": 2,
  "processed_queries": 0,
  "created_at": "2026-07-09T22:30:00Z"
}

Retrieve Batch Results

Poll this endpoint to retrieve the current state and answers for a batch job.

Once completed, download the full array of verified results by appending /results to the path:

Webhooks & Support

Step 6: Webhook Setup (Enterprise Tier only)

Enterprise subscribers can configure webhook endpoints to receive immediate event payload push notifications when a batch job finishes processing.

When a batch job moves to a terminal state (COMPLETED or FAILED), Calera server executes a POST request containing details to your registered endpoint:

Webhook Payload Example

{
  "event": "batch.completed",
  "batch_id": "batch_abc123xyz789",
  "total_queries": 2,
  "status": "COMPLETED",
  "completed_at": "2026-07-09T22:32:15Z"
}

Step 7: Support Escalation

We provide multiple assistance channels depending on your active plan tier:

• Developer Forum: Discuss integration patterns and general implementation questions at discourse.local.
• Priority Slack: Real-time engineering channel access included in Startup, Starter, and Professional tiers.
• Dedicated Enterprise Support: Direct escalations and SLA management via email at support@caleralabs.com.

Integration SDKs

Below are official code snippets showing how to implement asynchronous batch submission and result polling in multiple languages.

import time
import requests

API_KEY = "your_license_key_here"
BASE_URL = "https://financesec.api.caleralabs.com"

headers = {
    "X-License-Key": API_KEY,
    "Content-Type": "application/json"
}

# Submit batch
payload = {
    "queries": [
        "What is Tesla's FY22 gross margin?",
        "What is Amazon's FY23 operating margin?"
    ]
}

print("Submitting batch job...")
res = requests.post(f"{BASE_URL}/api/batch", json=payload, headers=headers)
res.raise_for_status()
job = res.json()
batch_id = job["batch_id"]
print(f"Job queued successfully. Batch ID: {batch_id}")

# Poll status
while True:
    res = requests.get(f"{BASE_URL}/api/batch/{batch_id}", headers=headers)
    res.raise_for_status()
    job = res.json()
    status = job["status"]
    processed = job["processed_queries"]
    total = job["total_queries"]
    
    print(f"Status: {status} ({processed}/{total} processed)")
    if status == "COMPLETED":
        print("\n=== Results ===")
        for result in job["results"]:
            print(f"Q: {result['query_id']} | Answer: {result['answer']['formatted'] if 'answer' in result else 'N/A'}")
        break
    elif status == "FAILED":
        print("Batch job failed.")
        break
        
    time.sleep(3)
                        

package main

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

const (
	apiKey  = "your_license_key_here"
	baseURL = "https://financesec.api.caleralabs.com"
)

type BatchRequest struct {
	Queries []string `json:"queries"`
}

type BatchResponse struct {
	BatchID          string `json:"batch_id"`
	Status           string `json:"status"`
	TotalQueries     int    `json:"total_queries"`
	ProcessedQueries int    `json:"processed_queries"`
}

func main() {
	client := &http.Client{Timeout: 10 * time.Second}
	
	reqBody, _ := json.Marshal(BatchRequest{
		Queries: []string{
			"What is Tesla's FY22 gross margin?",
			"What is Amazon's FY23 operating margin?",
		},
	})

	req, _ := http.NewRequest("POST", baseURL+"/api/batch", bytes.NewBuffer(reqBody))
	req.Header.Set("X-License-Key", apiKey)
	req.Header.Set("Content-Type", "application/json")

	resp, err := client.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()

	var job BatchResponse
	json.NewDecoder(resp.Body).Decode(&job)
	fmt.Printf("Queued Batch: %s (Status: %s)\n", job.BatchID, job.Status)

	// Poll results
	for {
		time.Sleep(3 * time.Second)
		pollReq, _ := http.NewRequest("GET", baseURL+"/api/batch/"+job.BatchID, nil)
		pollReq.Header.Set("X-License-Key", apiKey)
		
		pollResp, err := client.Do(pollReq)
		if err != nil {
			continue
		}
		
		var pollJob map[string]interface{}
		json.NewDecoder(pollResp.Body).Decode(&pollJob)
		pollResp.Body.Close()

		status := pollJob["status"].(string)
		fmt.Printf("Status: %s\n", status)

		if status == "COMPLETED" {
			results, _ := json.MarshalIndent(pollJob["results"], "", "  ")
			fmt.Println("=== Completed Results ===")
			fmt.Println(string(results))
			break
		}
	}
}
                        

const API_KEY = 'your_license_key_here';
const BASE_URL = 'https://financesec.api.caleralabs.com';

async function runBatch() {
  const response = await fetch(`${BASE_URL}/api/batch`, {
    method: 'POST',
    headers: {
      'X-License-Key': API_KEY,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      queries: [
        "What is Tesla's FY22 gross margin?",
        "What is Amazon's FY23 operating margin?"
      ]
    })
  });

  const job = await response.json();
  const batchId = job.batch_id;
  console.log(`Job queued. Batch ID: ${batchId}`);

  // Polling loop
  while (true) {
    await new Promise(r => setTimeout(r, 3000));
    
    const pollRes = await fetch(`${BASE_URL}/api/batch/${batchId}`, {
      headers: { 'X-License-Key': API_KEY }
    });
    const pollJob = await pollRes.json();
    
    console.log(`Status: ${pollJob.status} (${pollJob.processed_queries}/${pollJob.total_queries})`);
    
    if (pollJob.status === 'COMPLETED') {
      console.log('=== Results ===', JSON.stringify(pollJob.results, null, 2));
      break;
    } else if (pollJob.status === 'FAILED') {
      console.error('Job failed.');
      break;
    }
  }
}

runBatch().catch(console.error);