SynthBoard
PricingEnterprise
Log inGet Started→
API

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.

Create an API key Read the docs API spec

Native integrations on the platforms your team already uses

Zapier
n8n
Make
Pipedream
Activepieces
Arcade.dev

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.

Full reference →
MethodPathDescription
POST/api/v1/sessionsStart a session — boardroom or consult
POST/api/v1/sessions/planPreview the staffed board + credit estimate first
GET/api/v1/sessionsList your sessions
GET/api/v1/sessions/{id}Session state, decision brief, memo (optional wait)
POST/api/v1/sessions/{id}/forkDuplicate a session with altered context
POST/api/v1/sessions/{id}/outcomesGenerate action plan / report / memo
POST/api/v1/sessions/{id}/exportExport as markdown / json / text
POST/api/v1/synths/chat1-on-1 chat with a specific synth
POST/api/v1/actions/executeRun a board recommendation through a connected tool
POST/api/v1/webhooksRegister a webhook subscription
GET/api/v1/healthUnauthenticated health probe

Native adapters

Skip the code.

Install SynthBoard on the platform you already use — connect once, automate forever.

Zapier

Public integration with OAuth, webhook triggers, 10+ actions

n8n

Verified community node — OAuth + Bearer, on n8n Cloud

Make

Apps SDK modules for every session operation

Pipedream

Component package with actions and webhook sources

Activepieces

TypeScript piece — also exposed as an MCP tool

Arcade.dev

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.

Create an API key Read the docs

Product

  • Features
  • Session Modes
  • Synths
  • Session Assistant
  • Free Session
  • Integrations
  • Pricing
  • Compare

Solutions

  • For Founders
  • For Creators
  • For Product Leaders
  • For Consultants
  • For Teams
  • All use cases

By Method

  • AI Boardroom
  • AI Advisory Board
  • Decision Intelligence
  • AI Pre-Mortem
  • AI Stress Test
  • AI Council
  • Decision Autopsy
  • See all methods

By Decision

  • AI for Hiring
  • AI for Pricing
  • AI for Pivots
  • AI for Fundraising
  • AI for B2B vs B2C
  • See all decisions

By Audience

  • For Founders
  • For Consultants
  • For Investors
  • For Operators
  • For Coaches
  • See all audiences

Alternatives

  • McKinsey alternative
  • Business coach alternative
  • Advisory board alternative
  • Strategy consultant alternative
  • See all alternatives

Developers

  • Platform Overview
  • MCP Server
  • REST API
  • API Reference
  • Webhooks
  • Docs & Help
  • Security

Resources

  • Docs & Help
  • Blog
  • Glossary
  • Contact

Company

  • Manifesto
  • About
  • Enterprise

Legal

  • Privacy Policy
  • Terms of Service
  • Security
  • How We Hold Your Data
  • Refund Policy
Stay Updated

Get AI Insights Weekly

Join our newsletter for product updates, decision-making insights, and exclusive member content.

No spam, unsubscribe anytime. Read our Privacy Policy.

SynthBoardDecision Intelligence Platform
© 2026 SynthBoard

Built with ❤️ for the future of AI collaboration