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.
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.- 5,000+
- ideas analyzed
- 18.3%
- earn a go-verdict
- 50+
- live sources per scan
- ~60s
- to a scored verdict
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:
# 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, CodexStartup 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.
/api/agent/analysesanalysis:writeStart one analysis/api/agent/analyses/:idanalysis:readPoll one analysis/api/agent/analysis-batchesbatch:writeStart up to 10 analyses/api/agent/analysis-batches/:idbatch:readPoll a batch/api/agent/analysis-batches/:id/export?format=ideas-jsonexport:readExport batch as JSONSigning
Send x-preuve-key, x-preuve-timestamp, x-preuve-nonce, and x-preuve-signature. Nonces are single-use inside a five minute window.
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.
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 owneranalysis:readPoll single-run status and URLsbatch:writeCreate bounded batches up to 10 ideasbatch:readPoll batch status and child run URLsexport:readExport completed batch items as JSONResponses
Polling returns status and URLs. Report data stays in the authenticated dashboard or public share view.
{
"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 dispatchPROCESSINGThe existing Preuve deep analysis pipeline is runningCOMPLETEDThe dashboard URL is ready, and share URL is ready when publish is trueFAILEDThe run reached a terminal error with a stable codereportUrl
/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.