Run a boardroom
from any HTTP client.
Start sessions, capture decisions, ship outcomes — straight from your CRM, your CI, your Zap, your Slack bot. The same engine that powers SynthBoard.ai, with one secure key.
Native integrations on the platforms your team already uses
What you can build
A boardroom inside every workflow.
The API is the SynthBoard engine, exposed. Wire it into the tools your team already runs and let real decisions show up where the work happens.
Trigger a boardroom from your CRM
When a high-value deal stalls in HubSpot or Salesforce, fire a Zapier workflow that runs a Pre-Mortem session and posts the outcomes back as a deal note.
Auto-decide on Slack threads
Watch a Slack channel for messages tagged #decision. Run a Stress Test session, then post the synthesis back as a thread reply your team can act on.
Pre-mortem before a release
Hook the API into your CI. Before a major merge, run an Arena session to surface risks your reviewers missed — and gate the release on the score.
Custom GPTs and Claude projects
Wrap a few endpoints into a custom GPT or Claude project. Your users get an AI assistant that can run a real boardroom on demand.
Built for production
Everything you need, nothing you don't.
One engine, 46 endpoints
Every endpoint runs the same execution layer as the web app and the MCP server. A question in becomes a staffed board, a debate, and a decision memo out — no drift between transports.
Secure auth that just works
Use API keys for your own scripts, or let third-party tools like Zapier and ChatGPT auth in via OAuth. Scoped, IP-allowlisted, daily-capped — your call.
Real-time webhooks
Subscribe to session.complete, outcomes.ready, and more. Verified signatures, automatic retries, no missed events.
Enterprise-grade
Per-call audit logs, scoped access, encrypted at rest, and full data isolation. Built for teams that need answers without compromise.
Async by design
Board runs dispatch async — long-poll GET /sessions/{id}?wait_ms=60000 for completion, or subscribe to a webhook and let SynthBoard call you.
Native adapters
Ship-ready integrations for Zapier, n8n, Make, Pipedream, Activepieces, and Arcade. Plus an OpenAPI spec any client can consume.
Quickstart
Question in. Memo out.
Create a key in the Control Center, then: start → poll → read the memo. The decision brief staffs the board for you — no synth-picking required.
curl
# 1. Start a board
curl https://synthboard.ai/api/v1/sessions \
-H "Authorization: Bearer sb_live_..." \
-H "Content-Type: application/json" \
-d '{
"question": "Should we launch a free tier?",
"session_type": "boardroom",
"mode": "decision"
}'
# → { "session_id": "...", "task_id": "...", ... }
# 2. Long-poll until the run finishes
curl "https://synthboard.ai/api/v1/sessions/{id}?wait_ms=60000" \
-H "Authorization: Bearer sb_live_..."
# 3. Read the memo on the same response
# v4_phase: "done"
# memo: { verdict, confidence_0_100, conditions, dissent }Python (requests)
import requests
API = "https://synthboard.ai/api/v1"
H = {"Authorization": "Bearer sb_live_..."}
s = requests.post(f"{API}/sessions", headers=H, json={
"question": "Should we launch a free tier?",
"session_type": "boardroom",
"mode": "decision",
}).json()
session = {}
while session.get("v4_phase") != "done":
session = requests.get(
f"{API}/sessions/{s['session_id']}",
headers=H, params={"wait_ms": 60000},
).json()
print(session["memo"]["verdict"])TypeScript (fetch)
const API = "https://synthboard.ai/api/v1";
const headers = {
Authorization: "Bearer sb_live_...",
"Content-Type": "application/json",
};
const { session_id } = await fetch(`${API}/sessions`, {
method: "POST",
headers,
body: JSON.stringify({
question: "Should we launch a free tier?",
session_type: "boardroom",
mode: "decision",
}),
}).then((r) => r.json());
let session;
do {
session = await fetch(
`${API}/sessions/${session_id}?wait_ms=60000`,
{ headers },
).then((r) => r.json());
} while (session.v4_phase !== "done");
console.log(session.memo.verdict);The Consult — one expert, turn by turn
# Open a 1-on-1 with a named expert
curl https://synthboard.ai/api/v1/sessions \
-H "Authorization: Bearer sb_live_..." \
-H "Content-Type: application/json" \
-d '{
"question": "Tear down my pricing page",
"session_type": "consult",
"synth_id": "the-cmo"
}'Consult turns are driven through the MCP tool synthboard.consult.message — each call returns the expert's reply and any composed document, billed per turn. See the MCP docs.
Key endpoints
The shortlist.
| Method | Path | Description |
|---|---|---|
| POST | /api/v1/sessions | Start a session — boardroom or consult |
| POST | /api/v1/sessions/plan | Preview the staffed board + credit estimate first |
| GET | /api/v1/sessions | List your sessions |
| GET | /api/v1/sessions/{id} | Session state, decision brief, memo (optional wait) |
| POST | /api/v1/sessions/{id}/fork | Duplicate a session with altered context |
| POST | /api/v1/sessions/{id}/outcomes | Generate action plan / report / memo |
| POST | /api/v1/sessions/{id}/export | Export as markdown / json / text |
| POST | /api/v1/synths/chat | 1-on-1 chat with a specific synth |
| POST | /api/v1/actions/execute | Run a board recommendation through a connected tool |
| POST | /api/v1/webhooks | Register a webhook subscription |
| GET | /api/v1/health | Unauthenticated health probe |
Native adapters
Skip the code.
Install SynthBoard on the platform you already use — connect once, automate forever.
Public integration with OAuth, webhook triggers, 10+ actions
Verified community node — OAuth + Bearer, on n8n Cloud
Apps SDK modules for every session operation
Component package with actions and webhook sources
TypeScript piece — also exposed as an MCP tool
Remote MCP registration, verified-tier eligible
Webhooks, the way they should work.
Subscribe to real-time events. Every delivery is signed and retried up to five times. Wire session outcomes straight into Slack, your CRM, or your own event bus.
Webhook signing guide// Verify a SynthBoard webhook
import { createHmac, timingSafeEqual } from "node:crypto";
app.post("/webhooks/synthboard", (req, res) => {
const sig = req.header("X-SynthBoard-Signature").replace("sha256=", "");
const ts = req.header("X-SynthBoard-Timestamp");
const body = req.rawBody;
const expected = createHmac("sha256", SECRET)
.update(`${ts}.${body}`)
.digest("hex");
if (!timingSafeEqual(Buffer.from(sig), Buffer.from(expected)))
return res.status(401).end();
// Handle event
res.status(200).end();
});FAQ
Frequently asked.
What's the difference between the REST API and the MCP server?
Same engine, different transports. MCP is what Claude Desktop, Cursor, and ChatGPT speak natively. REST is what Zapier, n8n, Make, and any other HTTP client speaks. Both use the same auth and you can switch between them freely.
Do I need an API key or OAuth?
Either. For your own scripts, API keys are simplest — generate one in the Control Center. For third-party tools that act on behalf of your users (like Zapier), OAuth is the right path and the client auto-registers.
How do I pay for API calls?
Credits. Each session consumes credits based on the model assignment, synth count, and rounds. Pre-purchase credit bundles or run on a subscription — free tier included, no monthly minimum required.
What's the rate limit?
Per-endpoint buckets, tier-adjusted: the documented baselines apply to Pro, with Free ×0.15, Max ×3.3, and Ultra ×16 multipliers. Rate-limit errors include retry_after_s. The full matrix lives in the MCP docs under Rate limits.
How do webhooks work?
Register a subscription in the Control Center or via POST /api/v1/webhooks. We deliver signed events to your URL — session.complete, session.failed, session.cancelled, session.continued, outcomes.ready. Failed deliveries retry up to 5 times with backoff; after 10 consecutive failures the subscription auto-pauses until you re-enable it.
Is the REST API stable?
Yes. /api/v1/* is versioned and breaking changes require a new version. We commit to 90-day deprecation notice — announced in the changelog and by email to API key owners — before anything is retired. Full policy at /docs/versioning.
Ship the boardroom.
Generate an API key, run a session, wire the outcome back into your product.