Prism API

Dapto Prism API: From Questions to Execution - In Your Apps

Use one governed API to chat with any model, power agent workflows, and keep work organized across projects and teams. Prism brings Dapto’s routing, controls, and audit trail into your product-without vendor lock-in.

🔗 One API for every model🎯 Smart routing + override🤖 Agent-ready workflows💰 Cost + usage visibility🛡️ Governance built in
Same product, two ways to use it

Build in the Console. Ship via API.

Your team can prototype prompts, agents, and policies in Dapto AI Console, then reuse the same building blocks in your application through Prism API.

Workspaces
Shared configuration + access rules
Projects
Organize tasks and routing
Agents
Reusable execution playbooks
Multi-LLM
One contract, many models
Why Prism API

Production AI Integration Without the Chaos

Standardize multi-model AI in your product with routing, agent execution, and governance built in.

One API for Any Model

Call OpenAI, Gemini, Claude, Mistral, Llama, and self-hosted models through one endpoint.

Smart Routing + Override

Route by cost, quality, latency, or policy-and override when you need explicit control.

Governance Built In

Apply policies, redact sensitive data, and capture audit signals before calls ever hit the model.

Agent-Ready Execution

Turn prompt chains into reusable workflows your app can run reliably at scale.

Cost + Usage Visibility

Track spend per key, team, workspace, or project-set caps and get alerted early.

Future-Proof Integration

Add or switch models without rewriting your app. Keep your interface stable.

Key Capabilities

From Simple Calls to Full Execution

Prism API isn’t just model access-it’s the execution layer behind Dapto’s AI workspace.

1. Universal Multi-Model Endpoint

  • Single endpoint for OpenAI, Anthropic, Google, Mistral, open-source, and self

  • BYOK (bring your own keys) or managed keys with quotas, limits, and usage controls.

  • Switch, combine, or compare model outputs programmatically-without vendor lock

2. Routing That Matches the Task

  • Route by cost, policy, latency, or quality (and always keep manual override).

  • Task-based routing: match summarization vs analysis vs extraction to the best model.

  • Fallbacks and guardrails to keep results reliable when a model is unavailable or restricted.

3. Governance That Travels With the Call

  • Central policy enforcement across models (prompt + response).

  • Redaction of PII/PHI/sensitive content before dispatch and before returning to users.

  • Audit signals per call (who/what/where/which model), exportable to SIEM/compliance systems.

4. Developer-First Experience

  • Predictable request/response format across providers, with clean error handling.

  • Versioning, environments (sandbox), and async-friendly patterns for high-volume workloads.

  • SDK-ready surface area so teams can integrate fast (and keep maintenance low).

5. Agents & Workflow Execution

  • Run multi-step workflows: draft → refine → extract → format.

  • Reuse agent instructions across apps and teams for consistent results.

  • Trigger workflows from events (webhooks) or scheduled jobs.

6. Usage & Cost Intelligence

  • Track spend per project, workspace, key, model, or route strategy.

  • Set quotas/caps and get alerts for anomalies or runaway usage.

  • Build cost-aware experiences for your users with pricing predictability.

See Prism API in Action

A Single Call - With Execution Signals

Same endpoint, any model. Routing, policy checks, and audit signals included in the response.

Multi-Model API Call Example

Request

POST https://api.dapto.ai/v1/chat/completions
Authorization: Bearer YOUR_API_KEY
Content-Type: application/json
{
"messages": [
{"role": "user", "content": "Draft a QBR summary and action plan from these notes..."}
],
"routing": {
"strategy": "quality_first",
"fallback": "cost_optimized"
},
"context": {
"workspace_id": "ws_finance",
"project_id": "proj_qbr_2026_q1"
},
"governance": {
"redact_sensitive": true,
"audit_level": "standard"
}
}

Response

{
"id": "chatcmpl-abc123",
"model_used": "gpt-4o-mini",
"routing_reason": "quality_first",
"context": { "workspace_id": "ws_finance", "project_id": "proj_qbr_2026_q1" },
"governance": {
"sensitive_redacted": 2,
"policy_violations": 0,
"audit_id": "audit_xyz789"
},
"choices": [{ "message": { "role": "assistant", "content": "Here’s the QBR summary..." } }],
"usage": { "total_tokens": 512, "cost_usd": 0.0061 }
}

What Prism did automatically:

Governance

Redacted sensitive data + applied policies

Routing

Selected the best model for the strategy

Audit Signals

Returned audit_id + usage for traceability

Works for chat, tools, and agents
Same policies as the Console
Per-project cost controls
Model-agnostic responses

Put Dapto Into Your Product

Use Prism API to power multi-model chat, agent execution, and governed AI workflows-while keeping spend and control predictable.

One API • Any model • Routing • Agents • Projects • Governance