The Preuve AI startup validation API lets any AI agent validate startup ideas programmatically. The signed (HMAC) Agent API is available today and works with Claude Code, Cursor, Codex, and custom scripts. It runs the full Preuve deep analysis and returns a viability score, market research, competitor analysis, and a shareable report URL. A one-line CLI (npx @preuve/cli) and a Model Context Protocol (MCP) server are coming soon.

MCP · CLI · Agent API

Validate the idea before your agent builds it.

Your agent ships in minutes, but only 18.3% of ideas earn a go. Preuve runs a full, source-linked viability check inside Claude Code, Cursor, or Codex.

preuve.validate - preview
You: validate "AI standup bot for remote teams" before we build it

agent  →  preuve.validate(idea)
  ✓ Viability 38/100 - weak demand, crowded category
  ✗ 3 blocking risks - 12 active competitors
  →  Don't build it yet. 2 stronger pivots attached.
Works withClaude CodeCursorCodexCustom scriptsData pipelines
5,000+
ideas analyzed
18.3%
earn a go-verdict
50+
live sources per scan
~60s
to a scored verdict
Coming soon

Validate before you vibe-code

The MCP server and a one-line npx @preuve/cli wrap the signed Agent API, so your agent can validate an idea mid-build, no signing code by hand. Get it first:

No spam. One email when it ships.

zsh
# Coming soon
npx @preuve/cli analyze "A workflow tool for solo founders" --publish

# Or wire the MCP server into your agent
npx @preuve/cli mcp install   # registers with Claude Code, Cursor, Codex

Startup validation API

Available now. This signed AI agent API creates analysis runs, polls report status, returns the same dashboard reports a human user sees, and exports completed batches as structured JSON.

Endpoints

API keys are created from Account settings. Analysis usage is charged to the owning account quota.

POST/api/agent/analysesanalysis:writeStart one analysis
GET/api/agent/analyses/:idanalysis:readPoll one analysis
POST/api/agent/analysis-batchesbatch:writeStart up to 10 analyses
GET/api/agent/analysis-batches/:idbatch:readPoll a batch
GET/api/agent/analysis-batches/:id/export?format=ideas-jsonexport:readExport batch as JSON

Signing

Send x-preuve-key, x-preuve-timestamp, x-preuve-nonce, and x-preuve-signature. Nonces are single-use inside a five minute window.

bash
body='{"clientRunId":"run-online-001","idea":"A workflow automation service for solo founders that validates market demand before they build.","publish":true}'
timestamp=$(date -u +"%Y-%m-%dT%H:%M:%S.000Z")
nonce=$(openssl rand -hex 16)
body_hash=$(printf "%s" "$body" | openssl dgst -sha256 -binary | xxd -p -c 256)
canonical="POST
/api/agent/analyses

$body_hash
$timestamp
$nonce"
signature="sha256=$(printf "%s" "$canonical" | openssl dgst -sha256 -hmac "$PREUVE_AGENT_SECRET" -binary | xxd -p -c 256)"

curl https://preuve.ai/api/agent/analyses \
  -H "content-type: application/json" \
  -H "x-preuve-key: $PREUVE_AGENT_KEY" \
  -H "x-preuve-timestamp: $timestamp" \
  -H "x-preuve-nonce: $nonce" \
  -H "x-preuve-signature: $signature" \
  --data "$body"

Node client

Keep PREUVE_AGENT_SECRET server-side. The canonical query line is empty when the request has no query parameters.

node
import { createHash, createHmac, randomUUID } from 'node:crypto';

async function signedFetch(path, { method = 'GET', body } = {}) {
  const rawBody = body ? JSON.stringify(body) : '';
  const timestamp = new Date().toISOString();
  const nonce = randomUUID();
  const canonical = [
    method,
    path,
    '',
    createHash('sha256').update(rawBody).digest('hex'),
    timestamp,
    nonce,
  ].join('\n');
  const signature = createHmac('sha256', process.env.PREUVE_AGENT_SECRET)
    .update(canonical)
    .digest('hex');

  return fetch(`https://preuve.ai${path}`, {
    method,
    headers: {
      'content-type': 'application/json',
      'x-preuve-key': process.env.PREUVE_AGENT_KEY,
      'x-preuve-timestamp': timestamp,
      'x-preuve-nonce': nonce,
      'x-preuve-signature': `sha256=${signature}`,
    },
    body: rawBody || undefined,
  });
}

Scopes

Scopes are exact. Write access for analyses does not grant export access.

analysis:writeCreate analysis runs for the key owner
analysis:readPoll single-run status and URLs
batch:writeCreate bounded batches up to 10 ideas
batch:readPoll batch status and child run URLs
export:readExport completed batch items as JSON

Responses

Polling returns status and URLs. Report data stays in the authenticated dashboard or public share view.

json
{
  "id": "run_123",
  "reportId": "report_123",
  "clientRunId": "run-online-001",
  "status": "PROCESSING",
  "progressStep": "MARKET_RESEARCH",
  "publish": true,
  "reportUrl": "https://preuve.ai/app/results?id=report_123",
  "shareUrl": "https://preuve.ai/share/abc123"
}

Status lifecycle

Batches aggregate child runs into PROCESSING, COMPLETED, PARTIAL, or FAILED.

PENDINGThe run record exists and is waiting for dispatch
PROCESSINGThe existing Preuve deep analysis pipeline is running
COMPLETEDThe dashboard URL is ready, and share URL is ready when publish is true
FAILEDThe run reached a terminal error with a stable code

reportUrl

/app/results?id=<reportId>

Private owner dashboard

shareUrl

/share/<shareId>

Public shared dashboard

ideas-json

ValidatedIdea[]

Compact batch export (JSON array)

Startup validation API FAQ

What is the Preuve startup validation API?

It is a signed HTTP API that runs the full Preuve deep analysis on a startup idea and returns a viability score, market research, competitor analysis, and a shareable report URL. You authenticate each request with an HMAC signature, so any AI agent, CLI, or backend script can validate ideas programmatically.

Can I run Preuve from Claude Code, Cursor, or Codex?

Yes. Any agent that can make a signed HTTP request can call the Agent API today, including Claude Code, Cursor, Codex, and your own scripts. A dedicated MCP server that wires Preuve into those agents as native tools is coming soon.

Is there a Preuve MCP server or CLI yet?

Not yet. The signed Agent API is live now. A one-line CLI (npx @preuve/cli) and a Model Context Protocol (MCP) server are in development. Join the waitlist above to get notified the moment they ship.

How do I get a startup validation API key?

Create an API key from your Account settings inside the Preuve dashboard. Each key carries explicit scopes (analysis:write, analysis:read, batch:write, batch:read, export:read), and analysis usage is charged to the owning account quota.

What does the API return?

Polling returns the run status, progress step, and URLs. You get a private dashboard URL (reportUrl), an optional public share URL (shareUrl) when publish is true, and a compact ideas-json export for completed batches. The full report data stays inside the authenticated dashboard or the public share view.

How much does the validation API cost?

API usage draws from the same analysis quota as your Preuve plan, so there is no separate API fee. See the pricing page for plan limits and per-scan allowances.

Should I validate before using an autonomous agent like Polsia?

Yes. Autonomous build agents such as Polsia execute fast but skip the demand-validation step, which is where most teams burn their runway. Run the idea through the Preuve validation API first, then hand a validated brief to your build agent. See the linked Polsia review for a deeper breakdown of that gap.

New to Preuve? See how the analysis works on the idea validation page, browse real example reports, or check pricing and scan limits. Weighing an autonomous build agent? Read our honest Polsia review on why validation has to come first.