Skip to main content

ZeqCompliance Envelope

Per-call audit envelope (zeq.compliance.v1) returned automatically on every /api/zeq/compute response. Hash-chained, deterministic, satisfies FDA 21 CFR Part 11 (ALCOA), EU GMP Annex 11, ISO/IEC 27001, ISO 13485, SOX/SOC 2, DO-178C/ARP4754A, NIST SP 800-53, and GDPR Art. 30. Bound cryptographically to ZeqProof so any third party can verify the record matches the computation it certifies. Surfaces actor, action, temporal (1.287 Hz / 0.777s phase lock), output digests, and per-standard regulatory mappings. Headers: X-Zeq-Compliance-Envelope, X-Zeq-Compliance-Schema.

Protocol IDzeq-compliance
CategoryODE solver, master equation
Version1.0
Endpoint/api/zeq/compute 🔵 POST
AuthenticationRequired (Bearer API key)
Rate Limitinherits compute

Purpose​

Per-call audit envelope (zeq.compliance.v1) returned automatically on every /api/zeq/compute response. Hash-chained, deterministic, satisfies FDA 21 CFR Part 11 (ALCOA), EU GMP Annex 11, ISO/IEC 27001, ISO 13485, SOX/SOC 2, DO-178C/ARP4754A, NIST SP 800-53, and GDPR Art. 30. Bound cryptographically to ZeqProof so any third party can verify the record matches the computation it certifies. Surfaces actor, action, temporal (1.287 Hz / 0.777s phase lock), output digests, and per-standard regulatory mappings. Headers: X-Zeq-Compliance-Envelope, X-Zeq-Compliance-Schema. It belongs to the ODE solver, master equation family and is callable as a single REST endpoint, a one-line SDK call, or via streaming where applicable.

What it does​

When you call /api/zeq/compute, Zeq runs the ZeqCompliance Envelope computation through the KO42 metric tensioner under the active HulyaPulse phase. The result is sealed at the next Zeqond boundary (0.777 s) and returned with a verifiable ZeqProof receipt — meaning the same inputs at the same phase always produce the same output, and any third party can later verify the result was computed at the time you claim.

In practice, this protocol takes the parameters listed below, performs its ode solver, master equation operation, and returns a structured response containing the computation output plus phase-locking metadata (zeqondTick, hulyaPhase, zeqProof).

When to use it​

Reach for ZeqCompliance Envelope when you need a ode solver, master equation primitive that:

  • Must be reproducible — every call is deterministic for a given phase
  • Must be auditable — every response carries a tamper-evident ZeqProof receipt
  • Must compose with other Zeq protocols — outputs are phase-aligned to 1.287 Hz so they slot directly into downstream calls without resync
  • Must scale across domains — the same endpoint works whether you're driving one call per minute or part of a high-throughput pipeline (subject to rate limit inherits compute)

If you only need a one-shot ode solver, master equation answer with no audit trail and no composition with other Zeq calls, a plain library may be cheaper. If you need any of the four properties above, this protocol is the right tool.

How to call it​

The fastest path is a single HTTPS POST request to /api/zeq/compute with a Bearer token. You can use cURL, JavaScript, Python, or any HTTP client — examples for all three are below. The response is JSON.

Parameters​

No required parameters. Send an empty JSON body {} or include domain-specific fields.

Returns​

{ schema:

How to call it — every language​

Every Zeq endpoint is a plain HTTPS POST. That means you can call it from any language that speaks HTTP. Below: thirteen working snippets — pick whichever fits your stack.

Command line (curl)​

curl -X POST \
  https://www.zeq.dev/api/zeq/compute \
  -H "Authorization: Bearer $ZEQ_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{}'

JavaScript (browser / Node)​

const res = await fetch("https://www.zeq.dev/api/zeq/compute", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.ZEQ_API_KEY}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({}),
});
const data = await res.json();
console.log(data);

TypeScript​

interface ZeqResponse<T = unknown> {
  ok: boolean;
  result: T;
  zeqondTick: number;
  hulyaPhase: number;
  zeqProof: string;
}

const res = await fetch("https://www.zeq.dev/api/zeq/compute", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.ZEQ_API_KEY}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({}),
});
const data: ZeqResponse = await res.json();
console.log(data.result);

Python​

import os, requests

res = requests.post(
    "https://www.zeq.dev/api/zeq/compute",
    headers={"Authorization": f"Bearer {os.environ['ZEQ_API_KEY']}"},
    json={},
)
print(res.json())

Go​

package main

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

func main() {
    payload, _ := json.Marshal(map[string]interface{}{})
    req, _ := http.NewRequest("POST", "https://www.zeq.dev/api/zeq/compute", bytes.NewBuffer(payload))
    req.Header.Set("Authorization", "Bearer "+os.Getenv("ZEQ_API_KEY"))
    req.Header.Set("Content-Type", "application/json")
    res, _ := http.DefaultClient.Do(req)
    defer res.Body.Close()
    body, _ := io.ReadAll(res.Body)
    fmt.Println(string(body))
}

Java​

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class ZeqCall {
  public static void main(String[] args) throws Exception {
    HttpClient client = HttpClient.newHttpClient();
    HttpRequest req = HttpRequest.newBuilder()
        .uri(URI.create("https://www.zeq.dev/api/zeq/compute"))
        .header("Authorization", "Bearer " + System.getenv("ZEQ_API_KEY"))
        .header("Content-Type", "application/json")
        .POST(HttpRequest.BodyPublishers.ofString("{}"))
        .build();
    HttpResponse<String> res = client.send(req, HttpResponse.BodyHandlers.ofString());
    System.out.println(res.body());
  }
}

C​

#include <stdio.h>
#include <stdlib.h>
#include <curl/curl.h>

int main(void) {
    CURL *curl = curl_easy_init();
    if (!curl) return 1;
    struct curl_slist *headers = NULL;
    char auth[256];
    snprintf(auth, sizeof(auth), "Authorization: Bearer %s", getenv("ZEQ_API_KEY"));
    headers = curl_slist_append(headers, auth);
    headers = curl_slist_append(headers, "Content-Type: application/json");
    curl_easy_setopt(curl, CURLOPT_URL, "https://www.zeq.dev/api/zeq/compute");
    curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "POST");
    curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
    curl_easy_setopt(curl, CURLOPT_POSTFIELDS, "{}");
    curl_easy_perform(curl);
    curl_slist_free_all(headers);
    curl_easy_cleanup(curl);
    return 0;
}

C++​

#include <iostream>
#include <cstdlib>
#include <curl/curl.h>

int main() {
    CURL* curl = curl_easy_init();
    if (!curl) return 1;
    struct curl_slist* headers = nullptr;
    std::string auth = "Authorization: Bearer ";
    auth += std::getenv("ZEQ_API_KEY");
    headers = curl_slist_append(headers, auth.c_str());
    headers = curl_slist_append(headers, "Content-Type: application/json");
    curl_easy_setopt(curl, CURLOPT_URL, "https://www.zeq.dev/api/zeq/compute");
    curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "POST");
    curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
    curl_easy_setopt(curl, CURLOPT_POSTFIELDS, R"json({})json");
    curl_easy_perform(curl);
    curl_slist_free_all(headers);
    curl_easy_cleanup(curl);
}

PHP​

<?php
$ch = curl_init("https://www.zeq.dev/api/zeq/compute");
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "POST");
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    "Authorization: Bearer " . getenv("ZEQ_API_KEY"),
    "Content-Type: application/json",
]);
curl_setopt($ch, CURLOPT_POSTFIELDS, '{}');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
$response = curl_exec($ch);
curl_close($ch);
echo $response;

Swift​

import Foundation

var req = URLRequest(url: URL(string: "https://www.zeq.dev/api/zeq/compute")!)
req.httpMethod = "POST"
req.setValue("Bearer \(ProcessInfo.processInfo.environment["ZEQ_API_KEY"] ?? "")", forHTTPHeaderField: "Authorization")
req.setValue("application/json", forHTTPHeaderField: "Content-Type")
req.httpBody = "{}".data(using: .utf8)

URLSession.shared.dataTask(with: req) { data, _, _ in
    if let data = data { print(String(data: data, encoding: .utf8) ?? "") }
}.resume()

Lua​

local http = require("socket.http")
local ltn12 = require("ltn12")
local response = {}

http.request{
    url = "https://www.zeq.dev/api/zeq/compute",
    method = "POST",
    headers = {
        ["Authorization"] = "Bearer " .. os.getenv("ZEQ_API_KEY"),
        ["Content-Type"] = "application/json",
        ["Content-Length"] = tostring(#'{}'),
    },
    source = ltn12.source.string('{}'),
    sink = ltn12.sink.table(response),
}
print(table.concat(response))

HTML (drop into any page)​

<script>
fetch("https://www.zeq.dev/api/zeq/compute", {
  method: "POST",
  headers: {
    "Authorization": "Bearer YOUR_ZEQ_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({}),
})
  .then(r => r.json())
  .then(data => console.log(data));
</script>

Markdown / REST Client (.http)​

POST https://www.zeq.dev/api/zeq/compute
Authorization: Bearer {{ZEQ_API_KEY}}
Content-Type: application/json

{}

Phase-Locking & ZeqProof​

Every response from /api/zeq/compute carries:

  • zeqondTick — the Zeqond (0.777 s) at which the result was sealed
  • hulyaPhase — the HulyaPulse phase ∈ [0, 1) at sealing
  • zeqProof — HMAC receipt that lets any third party verify the result without an API key via POST /api/zeq/prove/verify

See Concepts → ZeqProof and HulyaPulse for the underlying mathematics.