API documentation

Quickstart

Your first governed decision in minutes: one call returns a verdict before the action runs, with signed proof you can hand to anyone.

Make your first governed decision

Pick your tool. Same action, same verdict, same proof — or run the sandbox in the right rail first, no key needed.

Get an API key

Create a workspace at decionis.com/create-account — the key is issued on signup. Exploration keys evaluate 50 decisions a month, free.

Evaluate an action before it runs

curl -X POST https://api.decionis.com/v1/protocol/evaluate-decision \
  -H "Authorization: Bearer $DECIONIS_API_KEY" \
  -H "Idempotency-Key: refund-ord_84f21" \
  -H "Content-Type: application/json" \
  -d '{
    "decision_type": "ISSUE_REFUND",
    "amount": 1200,
    "mode": "ENFORCEMENT"
  }'

Read the verdict

{
  "outcome": "ESCALATE",
  "confidence": 1,
  "policy_version": "refund-authority-v3",
  "objective_profile": "risk_conservative",
  "dossier_id": "3f6c…",
  "dossier_sha256": "ab12…",
  "evaluation_id": "9d41…",
  "mode": "ENFORCEMENT",
  "idempotent_replay": false
}

ESCALATE means a human decides before anything executes. APPROVE executes, REJECT stops, REVIEW queues. Example values shown — your ids and policy version will differ.

These are the wire spellings of the three decision classes the rest of this site calls ALLOW / ESCALATE / BLOCK: APPROVE is the allow class, REJECT is the block class, and ESCALATE / REVIEW are both holds — routed to a named approver versus queued without one. Same decisions, stable wire tokens (integrations branch on them) — the glossary maps every layer.

Prove it happened

curl https://api.decionis.com/v1/public/decision-dossiers/$DOSSIER_ID/verify

No account needed — anyone holding the link can re-verify the signature against the published JWKS.

Install the SDK

npm install @decionis/sdk

Gate the action

import { createDecionisNodeSdk } from "@decionis/sdk";

const gate = createDecionisNodeSdk({
  baseUrl: "https://api.decionis.com",
  apiKey: process.env.DECIONIS_API_KEY!,
});

const decision = await gate.evaluateDecision(
  { decision_type: "ISSUE_REFUND", amount: 1200, mode: "ENFORCEMENT" },
  { idempotencyKey: "refund-ord_84f21" },
);

if (decision.outcome !== "APPROVE") throw new Error(decision.outcome);
await payments.refund(order); // runs only after an approved decision

Read the verdict

decision.outcome is APPROVE, ESCALATE, REJECT, or REVIEW — the wire spellings of the site's ALLOW / ESCALATE / BLOCK classes (REVIEW is the queued hold); decision.dossier_id is the signed proof. The same idempotency key always returns the same decision.

Add the server to your agent host

# Claude Code
claude mcp add decionis -- npx -y @decionis/mcp

# .codex/config.toml — Codex and Copilot hooks work the same way
[mcp_servers.decionis]
command = "npx"
args = ["-y", "@decionis/mcp"]
required = true

See a verdict in one minute — no key, no approval gate

Ask your agent to call decionis_demo: four canned intents through the real protocol evaluator — one per wire outcome — entirely locally, nothing recorded. The five core tools are read-only and local; the Shield tools the server also lists call the Shield service once the assistant is paired.

Let policy gate the tool calls

Every tool call is evaluated before it runs — outside the model's discretion. APPROVE continues; REJECT, REVIEW, and ESCALATE stop the call. Network failure and invalid input deny. A repository with no policy file is denied by a per-repository hook; the Claude Code plugin reports it as not governed and lets the call through. Full tool reference: the MCP server docs.

What you just did

A verdict before execution. The action waited for policy; nothing ran on an ESCALATE or REJECT.
Signed, portable proof. Every decision leaves an Ed25519-signed Decision Dossier that verifies offline against the published JWKS — auditors and counterparties do not have to trust your logs.
Fail closed when you enforce. With the SDK's enforceAndExecute, a timeout, invalid proof or an unreachable authority means your action does not run. A bare evaluation call returns the verdict, and your code decides what to do with it. Start in shadow mode to watch verdicts on real traffic before enforcing anything.

Partner onboarding

Enterprise and partner integrations onboard through sponsor OTP, sample-driven signal mapping, and a one-step deployment bundle.

Show the full onboarding sequence →

# 1. Request the sponsor verification code
curl -X POST https://api.decionis.com/v1/public/auth/register/start \
  -H "Content-Type: application/json" \
  -d '{"owner_email":"risk@example.com","owner_name":"Partner Risk","org_name":"Partner Inc"}'

# 2. Verify the OTP → onboarding grant + org id
curl -X POST https://api.decionis.com/v1/public/auth/register/verify \
  -H "Content-Type: application/json" \
  -d '{"owner_email":"risk@example.com","otp_code":"123456"}'

# 3. Create a mapping session
curl -X POST https://api.decionis.com/v1/public/pilot/signal-mapping/sessions \
  -H "Authorization: Bearer <onboarding_grant>" \
  -d '{"org_id":"<org_uuid>"}'

# 4. Upload a representative sample (flat JSONL maps cleanest)
curl -X POST https://api.decionis.com/v1/public/pilot/signal-mapping/sessions/<session_id>/upload \
  -H "Authorization: Bearer <onboarding_grant>" \
  -H "Content-Type: application/x-ndjson" \
  --data-binary @sample_events_flat.jsonl

# 5. Dry-run the mapping
curl -X POST https://api.decionis.com/v1/public/pilot/signal-mapping/sessions/<session_id>/dry-run \
  -H "Authorization: Bearer <onboarding_grant>"

# 6. Issue the deployment bundle → org API key, connector id,
#    webhook secret + URL, policy version, in one step
curl -X POST https://api.decionis.com/v1/public/pilot/signal-mapping/sessions/<session_id>/deployment-bundle \
  -H "Authorization: Bearer <onboarding_grant>" \
  -d '{"provider_key":"partner_webhook","workflow_key":"decision_intake","source_label":"primary_stream"}'

# 7. Send live traffic into the issued webhook
curl -X POST https://api.decionis.com/v1/signals/webhooks/<connector_id> \
  -H "x-webhook-secret: whsec_xxx" \
  -d '{"events":[{"type":"eligibility_assessed","data":{"case_id":"case_123"}}]}'

# Minimum runtime env after bundle issuance:
DECIONIS_API_BASE_URL=https://api.decionis.com/v1
DECIONIS_API_KEY=...
DECIONIS_ORG_ID=...
DECIONIS_CONNECTOR_ID=...
DECIONIS_WEBHOOK_SECRET=...
DECIONIS_WEBHOOK_URL=...
DECIONIS_POLICY_VERSION=...

# Starter assets
curl -O https://docs.decionis.com/examples/sample_events_flat.jsonl
curl -O https://docs.decionis.com/examples/decionis.partner.env.example

Full route and payload details: signal mapping, webhooks. On Google Cloud, use the Vertex AI extension and its importable spec instead of improvising a second decision runtime.

Next steps

Each page pairs with a Try-It sample in the right rail.

You want to	Go to
Understand every field on the decision route	https://docs.decionis.com/decision-evaluation
Write and submit versioned policy	https://docs.decionis.com/policy-encoding
Watch verdicts on real traffic before enforcing	https://docs.decionis.com/shadow-reports
Verify, embed, or hand over a Decision Dossier	https://docs.decionis.com/decision-dossier
Gate agent tool calls in Claude Code, Codex, Copilot	https://decionis.ai/mcp
Wire inbound events and signed callbacks	https://docs.decionis.com/webhooks
Authentication, keys, and rate limits	https://docs.decionis.com/auth

On this page

evaluate.sh

Evaluate a decision

curl -X POST \
  https://api.decionis.com/v1/protocol/evaluate-decision \
  -H "Authorization: Bearer $DECIONIS_API_KEY" \
  -H "Idempotency-Key: refund-ord_84f21" \
  -d '{
    "decision_type": "ISSUE_REFUND",
    "amount": 1200,
    "mode": "ENFORCEMENT"
  }'

One call → APPROVE, ESCALATE, REJECT, or REVIEW, with a signed dossier.

Browser sandbox · deterministic · nothing leaves this page. The sample above runs against the live API with your key.