One request. A whole panel of specialists.

curl https://encevra.com/api/public/v1/panel \
  -H "Authorization: Bearer enc_live_..." \
  -H "Content-Type: application/json" \
  -d '{
    "question": "Should we sign the Aster renewal, or move to Boreal?",
    "material": "ASTER SYSTEMS — RENEWAL PROPOSAL ... BOREAL PLATFORM — PROPOSAL ..."
  }'

HTTP/1.1 202 Accepted
Retry-After: 10

{
  "object": "panel.run",
  "run_id": "a65dcf03-78e0-44a7-a99c-10231988d219",
  "status": "queued",
  "request_id": "9dd35145-...",
  "poll_url": "https://encevra.com/api/public/v1/runs/a65dcf03-...",
  "retry_after_seconds": 10,
  "estimated_duration_seconds": 90,
  "quota": {
    "runs_this_month": 12,
    "monthly_run_limit": 100,
    "rate_limit_per_minute": 6
  }
}

"engine": "noetis"   // default: seven specialists, up to 150,000 characters
"engine": "lite"     // three specialists, faster, up to 40,000 characters
"engine": "legal"    // any catalog template slug, see GET /api/public/v1/engines
"engine": "custom:<id>", "engine_version": 2   // your Engine Studio engine, pinned
"end_user": { "id": "u_123", "context": { "tone": "plain" } }   // optional, preferences only

GET    /api/public/v1/engines          // catalog: ids, versions, inputs, roles, tool availability
DELETE /api/public/v1/runs/<id>        // cancel a queued run (credit hold released, never charged)
PUT    /api/public/v1/end-users/<id>   // store end user preferences, scoped to your account
GET    /api/public/v1/end-users/<id>   // inspect them
DELETE /api/public/v1/end-users/<id>   // delete them

const r = await fetch("https://encevra.com/api/public/v1/panel", {
  method: "POST",
  headers: { Authorization: "Bearer " + process.env.ENCEVRA_KEY, "Content-Type": "application/json", "Idempotency-Key": crypto.randomUUID() },
  body: JSON.stringify({ engine: "procurement", mode: "async", question, material, webhook_url }),
});
const { run_id, poll_url } = await r.json();
// poll poll_url (or wait for the signed webhook) until status is released, incomplete or failed

curl https://encevra.com/api/public/v1/runs/a65dcf03-... \
  -H "Authorization: Bearer enc_live_..."

# while the panel is working
{ "status": "running", "retry_after_seconds": 10, ... }

# once it is done, the full panel.run object below

Encevra-Signature: t=1760000000,v1=<hex HMAC-SHA256>

signed_payload = t + "." + raw_request_body
expected = HMAC_SHA256(your_webhook_secret, signed_payload)

POST /api/public/v1/email-in
x-encevra-email-secret: <your intake secret>

{
  "from": "buyer@yourcompany.com",
  "to": "analyse@in.encevra.com",
  "subject": "Aster renewal - please review",
  "text": "plain-text body of the forwarded email",
  "attachment_text": "extracted text of the attached contract",
  "attachment_name": "aster-renewal.pdf",
  "question": "optional override; otherwise built from the subject"
}

Authorization: Bearer enc_live_...

{
  "run_id": "3d4fbb61-77a2-452b-8fe9-f7bbe706c23b",
  "request_id": "0f2a...",
  "object": "panel.run",
  "question": "Should we sign the Aster renewal, or move to Boreal?",
  "specialists": [
    {
      "id": "terms",
      "name": "Terms reader",
      "focus": "Obligations, durations, renewal and termination language...",
      "model": "Claude Fable 5.1",
      "status": "ok",
      "findings": [
        {
          "label": "Auto-renewing 24-month term",
          "statement": "The term renews for successive 12-month periods unless cancelled 90 days ahead.",
          "citation": {
            "quote": "auto-renewing for successive 12-month periods unless cancelled 90 days",
            "status": "verified",
            "start": 118,
            "end": 188
          }
        }
      ],
      "citations": { "findings": 3, "verified": 3, "unverified": 0, "rate": 1 },
      "report": "Auto-renewing 24-month term: ...",
      "error": null
    }
    // ...one entry per specialist
  ],
  "brief": {
    "text": "Bottom line: ...\nKey findings:\n- ...\nOpen questions:\n- ...",
    "model": "Claude Fable 5.1",
    "built_from": "verified findings only"
  },
  "citations": { "findings": 21, "verified": 20, "unverified": 1, "rate": 0.95 },
  "models_used": ["Claude Fable 5.1", "GPT-6 Astra", "Claude Opus 5.5"],
  "usage": {
    "input_tokens": 15675,
    "output_tokens": 10458,
    "cost_usd": 0.281,
    "estimated": false,
    "by_model": [
      { "model": "claude-fable-5-1", "calls": 7, "inputTokens": 12667, "outputTokens": 7963, "costUsd": 0.2624 },
      { "model": "gpt-6-astra", "calls": 2, "inputTokens": 1188, "outputTokens": 366, "costUsd": 0.0133 }
    ]
  },
  "quota": {
    "runs_this_month": 12,
    "monthly_run_limit": 100,
    "rate_limit_per_minute": 6
  },
  "duration_ms": 58213
}

{ "status": "ok", "service": "encevra-panel-api", "version": "1", "specialists": 8 }

"quota": { "runs_this_month": 12, "monthly_run_limit": 100 }
"usage": { "input_tokens": 15675, "output_tokens": 10458, "cost_usd": 0.281, "estimated": false }

// Poll a run started by POST /api/public/v1/panel.
// Reads the key from an environment variable; never hardcode it.
const apiKey = process.env.ENCEVRA_API_KEY; // required: enc_live_... or enc_test_...
if (!apiKey) throw new Error("Set ENCEVRA_API_KEY in your environment.");
const auth = { Authorization: `Bearer ${apiKey}` };

const TERMINAL = new Set(["released", "incomplete", "failed"]);
const TOTAL_TIMEOUT_MS = 10 * 60 * 1000; // give up after 10 minutes total
const MAX_RETRIES = 6; // bounded retries for 429 / 5xx, not for terminal states

async function pollRun(pollUrl) {
  const deadline = Date.now() + TOTAL_TIMEOUT_MS;
  let retryAfterMs = 10_000;
  let attempt = 0;

  while (Date.now() < deadline) {
    const res = await fetch(pollUrl, { headers: auth });

    if (res.status === 429 || res.status >= 500) {
      attempt += 1;
      if (attempt > MAX_RETRIES) throw new Error(`Polling failed after ${MAX_RETRIES} retries (last status ${res.status}).`);
      const retryAfterHeader = Number(res.headers.get("retry-after"));
      const backoffMs = Number.isFinite(retryAfterHeader) && retryAfterHeader > 0
        ? retryAfterHeader * 1000
        : Math.min(60_000, 1000 * 2 ** attempt);
      await sleep(backoffMs);
      continue;
    }

    if (!res.ok) {
      const body = await res.json().catch(() => ({}));
      throw new Error(`${body?.error?.code ?? res.status}: ${body?.error?.message ?? "request failed"}`);
    }

    const run = await res.json();
    attempt = 0; // reset backoff after a healthy response

    if (TERMINAL.has(run.status)) {
      if (run.status === "failed") throw new Error(run.error?.message ?? "The run failed.");
      return run; // "released" or "incomplete": read run.brief.text
    }

    retryAfterMs = (run.retry_after_seconds ?? 10) * 1000;
    await sleep(retryAfterMs);
  }

  throw new Error("Timed out waiting for the run to finish.");
}

function sleep(ms) {
  return new Promise((resolve) => setTimeout(resolve, ms));
}

// Verify a completion webhook POST. Reads the signing secret from an
// environment variable; it is issued alongside your API key.
// Header format: Encevra-Signature: t=<unix seconds>,v1=<hex HMAC-SHA256>
// signed_payload = "<t>.<raw request body>"
import { createHmac, timingSafeEqual } from "node:crypto";

const TOLERANCE_SECONDS = 300;

export function verifyEncevraWebhook(header, rawBody, secret) {
  if (!header) return { ok: false, reason: "missing_header" };

  const parts = Object.fromEntries(
    header.split(",").map((p) => p.trim().split("=")).filter((kv) => kv.length === 2),
  );
  const t = parts.t;
  const v1 = parts.v1;
  if (!t || !v1 || !/^d+$/.test(t) || !/^[0-9a-f]{64}$/i.test(v1)) {
    return { ok: false, reason: "malformed_header" };
  }

  const now = Math.floor(Date.now() / 1000);
  if (Math.abs(now - Number(t)) > TOLERANCE_SECONDS) {
    return { ok: false, reason: "stale_timestamp" };
  }

  const secretEnv = process.env.ENCEVRA_WEBHOOK_SECRET || secret;
  if (!secretEnv) return { ok: false, reason: "missing_secret" };

  let expected;
  try {
    expected = createHmac("sha256", secretEnv).update(`${t}.${rawBody}`).digest("hex");
  } catch {
    return { ok: false, reason: "bad_signature" };
  }

  const a = Buffer.from(expected, "hex");
  const b = Buffer.from(v1, "hex");
  if (a.length !== b.length || !timingSafeEqual(a, b)) {
    return { ok: false, reason: "bad_signature" };
  }
  return { ok: true };
}

// Example handler:
// app.post("/webhooks/encevra", express.raw({ type: "application/json" }), (req, res) => {
//   const result = verifyEncevraWebhook(req.header("Encevra-Signature"), req.body.toString("utf8"), process.env.ENCEVRA_WEBHOOK_SECRET);
//   if (!result.ok) return res.status(401).send("invalid signature");
//   const event = JSON.parse(req.body.toString("utf8"));
//   // event.type is "panel.run.completed" or "panel.run.failed"
//   res.status(200).send("ok");
// });

import os, time, requests

auth = {"Authorization": f"Bearer {os.environ['ENCEVRA_API_KEY']}"}

start = requests.post(
    "https://encevra.com/api/public/v1/panel",
    headers=auth,
    json={"question": question, "material": material},
    timeout=30,
)
start.raise_for_status()
job = start.json()

while True:
    time.sleep(job.get("retry_after_seconds", 10))
    run = requests.get(job["poll_url"], headers=auth, timeout=30).json()
    if run["status"] in ("released", "incomplete"):
        print(run["status"], run["brief"]["text"])
        break
    if run["status"] == "failed":
        raise RuntimeError(run["error"]["message"])

https://encevra.com/api/public/openapi.json