DOCUMENTATION
From zero to your first grounded physics computation in under 2 minutes.
Go to Pricing and start your free 14-day trial — no credit card required. Enter your email and your zeq_ak_… API key is generated instantly and shown once in your trial portal. Copy it immediately.
In your Replit project, open the Secrets panel (padlock icon in the left sidebar, or press Ctrl+K and search "Secrets"). Add a new secret:
ZEQ_API_KEY
zeq_ak_…
Restart your Repl after adding a secret so the environment variable is available.
Call POST /api/zeq/compute with a physics domain and inputs. Working examples in 10 languages — click a tab to switch:
Every successful compute request returns a zeqState object alongside the domain-specific result. Here is the full ZeqState structure:
Tip: validate KO42 presence and precision ≤ 0.001 in every response before using the result.
If you use Claude Desktop, Cursor, or Windsurf, you can connect Zeq.dev as a native AI tool. Add this to your AI client's config file, replace the placeholder key, and restart:
Once connected, your AI gains zeq_compute and zeq_list_operators as native tools. Full details on the MCP page.
All authenticated endpoints require an Authorization: Bearer zeq_ak_… header. Public endpoints have no auth requirement but are still rate-limited per IP. Daily token budgets reset at 00:00 UTC — exhaustion returns 429 DAILY_LIMIT_EXCEEDED.
| Endpoint | Auth | Rate limit | Consumes tokens |
|---|---|---|---|
| POST /api/zeq/compute | Auth | 60 / min | 1 per call |
| GET /api/zeq/pulse | Public | 60 / min | 0 — always free |
| GET /api/zeq/pulse/stream | Auth | 60 / min | 0 — SSE keepalive |
| POST /api/zeq/verify | Auth | 60 / min | 0 — proof check only |
| POST /api/zeq/lattice | Auth | 60 / min | N tokens (1 per node, 2–5) |
| POST /api/zeq/shift | Auth | 60 / min | steps tokens (1–64) |
| GET /api/zeq/usage | Auth | 60 / min | 0 |
| GET /api/operators | Public | 60 / min | 0 |
| GET /api/operators/categories | Public | 60 / min | 0 |
| GET /api/demo-key | Public | 30 / min | 0 — issues trial key |
Two public endpoints expose the full operator library — no API key required. Use them to build domain selectors, search UIs, or populate AI tool registries.
/api/operators
Public
60 req/min · No tokens consumed
Returns the full operator list with optional filtering. All query parameters are optional and combinable. Underscore and space notation are both accepted for multi-word domains.
| Query param | Type | Description |
|---|---|---|
| search | string | Substring match on operator name, ID, domain, or description (case-insensitive) |
| domain | string | Filter by domain — underscores or spaces accepted: quantum_mechanics and Quantum Mechanics both work. Alias of category. |
| category | string | Same as domain. Underscores or spaces accepted: fluid_dynamics or thermodynamics. |
| domainGroup | string | Filter to a group: Core Physics · Extended Physics · Applied Sciences · Industry · Frontier |
| limit | integer | Cap the number of operators returned after all filters. Omit or pass 0 to return all matching results. Response always includes the untruncated filtered count. |
/api/operators/categories
Public
60 req/min · No tokens consumed
Returns all 64 domain definitions sorted by group then name — including prefix codes and per-domain operator counts.
| Group | Domains |
|---|---|
| Core Physics | 16 |
| Extended Physics | 11 |
| Applied Sciences | 12 |
| Industry | 12 |
| Frontier | 13 |
| Total | 64 |
Every query to /api/zeq/compute, /api/zeq/lattice, /api/zeq/shift, and POST /api/mcp (JSON-RPC tools/call) runs through all seven steps in sequence. No query can skip a step. Constants are sourced directly from NIST CODATA 2018. The response always includes a protocol_steps[] array so you can audit what ran at each step.
Resolve operator IDs from the 1,536 verified physics operators. If none are specified, intent-aware selection picks the best match for your domain and inputs.
Bind NIST CODATA 2018 physical constants (ℏ, c, G, k_B, ε₀, N_A…) to the selected operators. Constants are scoped to the domain group (Core / Extended / Applied / Industry / Frontier).
Dimensional analysis and domain constraint checks. Mass must be ≥ 0, velocity must be < c, temperature must be ≥ 0 K, and all values must be finite. Violations are clamped and flagged in warnings[].
Domain-specific physics computation. Core domains use precise analytical solvers (quantum: E_n = n²π²ℏ²/2mL², orbital: v = √(G_mod·M/r), thermal: P = nRT/V, EM: F = q²/4πε₀r², …). Other domains use KO42-modulated formula evaluation.
Cross-check the result against the KO42 precision bound (≤ 0.1%). If the relative uncertainty exceeds 0.001, a precision warning is added to protocol_steps[4].detail. The result is never rejected — flagging is informational.
Synchronise to the 1.287 Hz HulyaPulse. Applies the KO42 modulation: R(t) = S(t) × [1 + α·sin(2π·f_H·t)] where α = 1.29×10⁻³ and τ = 0.777 s. Phase and Zeqond index are recorded.
Assemble the structured result: value, unit, uncertainty, operator_id, zeqState, result, protocol_steps[], and zeqProof HMAC. API version 2.0. VX mode label applied if the query ran in degraded (quota-exhausted) mode.
When a paid plan user's daily token allowance is exhausted, Step 4 runs with the VX operator (KO42 ground state only) and the response includes "mode":"VX". Free / Starter users over quota still receive 429 DAILY_LIMIT_EXCEEDED.
| Method | Endpoint | Auth | Tokens | Description |
|---|---|---|---|---|
| POST | /api/zeq/compute | Auth | 1 | 7-step physics computation. Returns value, unit, uncertainty, protocol_steps[]. |
| GET | /api/zeq/pulse | Public | 0 | Live HulyaPulse snapshot. Zeqond τ, phase φ, R(t), precision. |
| GET | /api/zeq/pulse/stream | Auth | 0 | SSE stream — live HulyaPulse event every 777 ms. |
| POST | /api/zeq/verify | Auth | 0 | Verify a zeqProof HMAC returned by /compute or /lattice. |
| POST | /api/zeq/lattice | Auth | N nodes | ZeqLattice — multi-node coherence grid. Each node runs the full 7-step wizard. |
| POST | /api/zeq/shift | Auth | N steps | ZeqShift — time-series projection across N future Zeqond steps. |
| GET | /api/zeq/usage | Auth | 0 | Token budget: used, remaining, plan, reset time. |
| GET | /api/operators | Public | 0 | All 1,536 operators. Filter by domain with ?domain=… |
| GET | /api/operators/:id | Public | 0 | Single operator by ID (e.g. QM-001, KO42, ZR-003). |
| GET | /api/operators/categories | Public | 0 | All 64 domain categories with group, prefix, and operator counts. |
| POST | /api/mcp | Auth | 1 | MCP JSON-RPC endpoint (method: "tools/call") — zeq_compute, zeq_list_operators, zeq_verify, zeq_lattice, zeq_shift, zeq_field_status. |
The ZeqField Protocols extend the core compute API with live pulse sync, tamper-evident proofs, multi-node coherence, time-series projection, and usage monitoring.
/api/zeq/pulse
Public
ZeqPulse · 60 req/min · No tokens
Live HulyaPulse snapshot — current Zeqond τ, phase φ, R(t), precision, and time to next tick. No API key required. Ideal as a heartbeat or for temporal anchoring in AI agents.
/api/zeq/pulse/stream
Auth
SSE · 777 ms tick · No tokens
Server-Sent Events stream — a live HulyaPulse event every 777 ms. Requires your API key. Ideal for real-time agent clock synchronisation. The server sends data: lines continuously; close the connection when done.
/api/zeq/usage
Auth
Usage · 60 req/min · No tokens
Returns your current token budget for the day — calls used, remaining, plan name, and UTC reset time. Use as a preflight check in automated pipelines to avoid unexpected 429 mid-batch.
/api/zeq/verify
Auth
ZeqProof · HMAC-SHA256 · No tokens
Verify the zeqProof HMAC attached to every compute response. Proves a physics result was generated at a specific Zeqond by the authenticated key — tamper-evident and auditable without storing a secret client-side.
| Request body field | Type | Required | Description |
|---|---|---|---|
| zeqProof | string | Yes | 64-char HMAC-SHA256 hex returned in the zeqProof field of the compute response |
| operatorIds | string[] | Yes | Operator IDs in the exact order returned by the compute response zeqState.operators |
| R_t | number | Yes | zeqState.masterSum from the compute response — pass all 6 decimal places |
| zeqond | integer | Yes | zeqState.zeqond from the compute response |
/api/zeq/lattice
Auth
ZeqLattice · 2–5 nodes · N tokens
Multi-domain coherence grid. Pass 2–5 node specs, each with a domain and inputs. All nodes share one Zeqond tick with staggered phase offsets. Returns per-node R_t values, a coherenceScore (0–1), and the lattice equation. Consumes N tokens — one per node.
| Request body field | Type | Required | Description |
|---|---|---|---|
| nodes | object[] | Yes | Array of 2–5 node objects, each with domain and inputs |
| nodes[].domain | string | Yes | Physics domain name (e.g. quantum_mechanics) or prefix code (e.g. QM) |
| nodes[].inputs | object | Yes | Domain-specific input parameters (key-value pairs of numeric values) |
/api/zeq/shift
Auth
ZeqShift · 1–64 steps · steps tokens
Forward time-series projection. Pass steps (1–64), a domain, and inputs. Returns a per-step array with exact deterministic R_t values 0.777 s apart. Consumes steps tokens.
| Request body field | Type | Required | Description |
|---|---|---|---|
| steps | integer | Yes | Number of projection steps. Range: 1–64. Each step is 0.777 s (one Zeqond) forward in time. |
| domain | string | Yes | Physics domain name (e.g. quantum_mechanics) or prefix code (e.g. QM) |
| inputs | object | Yes | Domain-specific input parameters (key-value pairs of numeric values) |
Pass any of these domain names (or their prefix codes) to domain in a compute request. Values shown are realistic representative inputs.
Browse the full operator library across 64 domains in the Operator Explorer ↗.
All compute requests require a valid zeq_ak_ API key in the Authorization header:
Connect Claude Desktop, Cursor, or Windsurf to the full physics operator library as native AI tools.
Machine-readable API reference structured for LLM ingestion. All endpoints, schemas, and ZeqState definition.
The HulyaSync mathematical framework — master equation, Zeqond, KO42, and the physics behind every computation.
Common questions about the framework, API keys, trial, pricing, MCP, and the math.