# DECA for agents > Demand signals, product ideas and real-ad demand tests for any agent, over MCP or REST. Agents write ideas. DECA proves whether real people want them. DECA is an agentic incubator. Its agents read what is rising in the App Store and Google Play every day, write consumer product ideas from it, and test them with ten days of real ads against a pass mark set before the first ad runs. Any agent can use the same machine: read the signals, read the ideas, and price a test of its own idea. - [Quickstart](https://app.decalabs.ai/docs/quickstart) · Your first call in under a minute, with no key and no account. - [Connect over MCP](https://app.decalabs.ai/docs/mcp) · Add DECA to Claude, Cursor, VS Code or your own agent. - [How a test is priced](https://app.decalabs.ai/docs/guides/pricing) · Only the ad budget, at cost, sized to the idea. - [Score an idea](https://app.decalabs.ai/docs/guides/score-idea) · One call and one USDC: your idea against live demand. - [REST API](https://app.decalabs.ai/docs/reference/rest) · The same tools as plain HTTPS endpoints. ## What you can do today | Tool | What it gives your agent | Cost | |---|---|---| | [`get_signals`](https://app.decalabs.ai/docs/tools/get-signals) | The day's demand patterns: apps climbing the charts, what people say and want, the posts behind it | Free | | [`get_ideas`](https://app.decalabs.ai/docs/tools/get-ideas) | Product ideas written from those patterns, judged worth testing, with their evidence and expected sign-up rate | Free | | [`get_my_ideas`](https://app.decalabs.ai/docs/tools/get-my-ideas) | Ideas written for your own workspace, each with why it is yours. Needs an API key | Free | | [`quote_test`](https://app.decalabs.ai/docs/tools/quote-test) | The price of a ten-day demand test for any idea, as budget options sized to it | Free | | [Score an idea](https://app.decalabs.ai/docs/guides/score-idea) | Your own idea scored against live demand: a verdict, the closest apps, the sign-ups to expect. REST only | 1 USDC | | [`start_test`](https://app.decalabs.ai/docs/guides/paid-tests) | A ten-day demand test with real ads, paid over x402 and reviewed by a person before its ads run | The ad budget, in USDC | | [`get_test` · `list_my_tests` · `cancel_test`](https://app.decalabs.ai/docs/guides/paid-tests) | A paid test's state, progress and result; your tests; a cancel while it is still in review | Free | Payments are in USDC on Base over [x402](https://x402.org) and are open today. A sandbox on Base Sepolia runs the same flow with test USDC. See [Paid tests](https://app.decalabs.ai/docs/guides/paid-tests). ## How it fits together 1. **Read.** `get_signals` and `get_ideas` return what DECA's radar found today, with the apps, reviews and posts it rests on. 2. **Price.** `quote_test` turns an idea, from the radar or your own, into a few budget options. Each says how many confirmed sign-ups it must reach to pass and what it can and cannot tell. 3. **Test.** Your agent pays the budget in USDC on Base over x402. DECA makes the brand, the page and the ads, runs them for ten days and records the pass mark on Base before the first ad and the result after the last. ## Built for agents - **No key to start.** Every tool works without an account. [Rate limits](https://app.decalabs.ai/docs/reference/limits) keep it fair. - **Plain JSON, always.** Every answer, over MCP or REST, is the same JSON object. Every error has a `code`, a `message` and a `next` step. See [Errors](https://app.decalabs.ai/docs/reference/errors). - **Readable by models.** Every page of these docs is also plain Markdown: add `.md` to its address. [`/llms.txt`](https://app.decalabs.ai/llms.txt) lists them all and [`/llms-full.txt`](https://app.decalabs.ai/llms-full.txt) holds them in one file. - **Described in OpenAPI.** [`/api/agent/openapi.json`](https://app.decalabs.ai/api/agent/openapi.json) for any client that reads it. Source: https://app.decalabs.ai/docs --- # Quickstart > Your first call to DECA in under a minute, with no key and no account. DECA needs no key and no account for reading signals, reading ideas and pricing a test. Pick the way your agent talks to tools. ## 1. Connect ```bash title="Claude Code" claude mcp add --transport http deca https://app.decalabs.ai/mcp ``` ```json title="Claude Desktop · Cursor" { "mcpServers": { "deca": { "type": "http", "url": "https://app.decalabs.ai/mcp" } } } ``` ```bash title="REST" curl https://app.decalabs.ai/api/agent/ideas?limit=1 ``` More clients, and one-click install buttons, are on [Connect over MCP](https://app.decalabs.ai/docs/mcp). ## 2. Ask for ideas Over MCP, ask your agent something like *"What product ideas does DECA have in photo apps?"* It will call `get_ideas` with `query: "photo"`. Over REST: ```bash title="cURL" curl "https://app.decalabs.ai/api/agent/ideas?query=photo&limit=3" ``` ```ts title="TypeScript" const res = await fetch("https://app.decalabs.ai/api/agent/ideas?query=photo&limit=3"); const { ideas } = await res.json(); for (const idea of ideas) console.log(idea.name, "·", idea.one_line); ``` ```python title="Python" import requests r = requests.get("https://app.decalabs.ai/api/agent/ideas", params={"query": "photo", "limit": 3}) for idea in r.json()["ideas"]: print(idea["name"], "·", idea["one_line"]) ``` Each idea carries its `evidence` (the apps and posts it rests on), its `expected` sign-up rate and a `url` a person can open. ## 3. Price a test Take an idea's `id`, or describe your own, and ask what testing it would cost: ```bash title="cURL" curl -X POST https://app.decalabs.ai/api/agent/quote \ -H "content-type: application/json" \ -d '{"idea": {"pitch": "A pantry app that tells families what to cook from what is about to expire"}, "markets": ["US", "GB"]}' ``` ```ts title="TypeScript" const res = await fetch("https://app.decalabs.ai/api/agent/quote", { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify({ idea: { pitch: "A pantry app that tells families what to cook from what is about to expire" }, markets: ["US", "GB"], }), }); const quote = await res.json(); for (const o of quote.options) console.log(o.label, `$${o.budget_usd}`, `pass at ${o.pass_line}`); ``` The answer lists a few options. The cheapest reliable one is marked `recommended`: ```json { "fee_usd": 0, "currency": "USDC", "network": "base", "recommended": "signal", "options": [ { "id": "signal", "label": "Signal: is there demand at all", "budget_usd": 700, "expected_visits": 737, "pass_line": 15 }, { "id": "clear", "label": "Clear read: a result that rests less on luck", "budget_usd": 1400, "expected_visits": 1474, "pass_line": 31 }, { "id": "compare", "label": "Market comparison: where it is strongest", "budget_usd": 1400, "expected_visits": 1484, "pass_line": 31, "pass_line_by_market": { "US": 15, "GB": 16 } } ] } ``` Read [How a test is priced](https://app.decalabs.ai/docs/guides/pricing) for what these numbers mean. ## Next - [`get_signals`](https://app.decalabs.ai/docs/tools/get-signals), [`get_ideas`](https://app.decalabs.ai/docs/tools/get-ideas) and [`quote_test`](https://app.decalabs.ai/docs/tools/quote-test) in full. - [Errors](https://app.decalabs.ai/docs/reference/errors): every code your agent can meet and what to do about it. Source: https://app.decalabs.ai/docs/quickstart --- # Connect over MCP > Add DECA to Claude, Cursor, VS Code or your own agent through the Model Context Protocol. DECA is a remote MCP server. It speaks streamable HTTP, answers every request with JSON and keeps no session, so any client that supports remote servers can use it. Server URL: `https://app.decalabs.ai/mcp` Claude Code: `claude mcp add --transport http deca https://app.decalabs.ai/mcp` | | | |---|---| | **Server URL** | `https://app.decalabs.ai/mcp` | | **Transport** | Streamable HTTP, JSON responses, no server-sent stream | | **Authentication** | None needed. An optional API key ties calls to your workspace; see [Authentication](https://app.decalabs.ai/docs/reference/authentication). | | **Protocol versions** | `2025-11-25`, `2025-06-18`, `2025-03-26`, `2024-11-05` | | **Tools** | `get_signals`, `get_ideas`, `get_my_ideas`, `quote_test`, `start_test`, `get_test`, `list_my_tests`, `cancel_test` | | **Registry** | `ai.decalabs/deca` in the [official MCP Registry](https://registry.modelcontextprotocol.io/v0.1/servers?search=ai.decalabs/deca) | ## Clients ```bash title="Claude Code" claude mcp add --transport http deca https://app.decalabs.ai/mcp ``` ```json title="Claude Desktop" { "mcpServers": { "deca": { "type": "http", "url": "https://app.decalabs.ai/mcp" } } } ``` ```json title="Cursor" { "mcpServers": { "deca": { "url": "https://app.decalabs.ai/mcp" } } } ``` ```json title="VS Code" { "servers": { "deca": { "type": "http", "url": "https://app.decalabs.ai/mcp" } } } ``` In Claude.ai, add it under **Settings → Connectors → Add custom connector** with the server URL. ## From your own agent Any MCP client library works. With the official TypeScript SDK: ```ts title="TypeScript" import { Client } from "@modelcontextprotocol/sdk/client/index.js"; import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js"; const client = new Client({ name: "my-agent", version: "1.0.0" }); await client.connect(new StreamableHTTPClientTransport(new URL("https://app.decalabs.ai/mcp"))); const { tools } = await client.listTools(); const result = await client.callTool({ name: "get_ideas", arguments: { query: "camera", limit: 3 } }); console.log(result.structuredContent); ``` ```python title="Python" import asyncio from mcp import ClientSession from mcp.client.streamable_http import streamablehttp_client async def main(): async with streamablehttp_client("https://app.decalabs.ai/mcp") as (read, write, _): async with ClientSession(read, write) as session: await session.initialize() result = await session.call_tool("get_ideas", {"query": "camera", "limit": 3}) print(result.structuredContent) asyncio.run(main()) ``` ```bash title="JSON-RPC" curl -X POST https://app.decalabs.ai/mcp \ -H "content-type: application/json" \ -d '{"jsonrpc": "2.0", "id": 1, "method": "tools/call", "params": {"name": "get_signals", "arguments": {"heat": "rising", "limit": 2}}}' ``` ## What a tool returns Every tool result carries the same object twice: as `structuredContent` for clients that read it, and as JSON text in `content` for those that do not. A failed call sets `isError: true` and its object is an [error](https://app.decalabs.ai/docs/reference/errors). ```json { "content": [{ "type": "text", "text": "{\"day\":\"2026-11-18\",\"count\":2,\"ideas\":[…]}" }], "structuredContent": { "day": "2026-11-18", "count": 2, "ideas": ["…"] }, "isError": false } ``` > **Tip** · The server's `instructions`, sent on `initialize`, tell the model what DECA is and when to use each tool. Most agents need nothing more than the server URL. Source: https://app.decalabs.ai/docs/mcp --- # get_signals > The day's demand patterns from DECA's radar, with the apps, reviews and posts behind them. **GET /api/agent/signals · MCP tool get_signals · Free** Every day DECA's radar reads the App Store and Google Play charts in dozens of countries, finds the apps that are climbing, and groups them into **patterns**: several apps answering the same want. For each pattern it listens to what people say about it in reviews and posts. `get_signals` returns those patterns, strongest first. ## Parameters | Name | Type | Description | |---|---|---| | `query` | string | Words that must all appear in the pattern, its apps or what people say. Optional. | | `heat` | `rising` · `steady` | Only patterns people are talking about this much. Optional. | | `limit` | integer | How many to return, 1 to 25. Default 10. | ## Request ```bash title="cURL" curl "https://app.decalabs.ai/api/agent/signals?heat=rising&limit=5" ``` ```json title="MCP" { "name": "get_signals", "arguments": { "heat": "rising", "limit": 5 } } ``` ```ts title="TypeScript" const res = await fetch("https://app.decalabs.ai/api/agent/signals?heat=rising&limit=5"); const { signals } = await res.json(); ``` ## Response ```json { "day": "2026-11-18", "read": { "apps": 36722, "charts": 1003, "pockets": 60, "rising": 14 }, "count": 1, "signals": [ { "id": 1632, "name": "Paid film-look camera apps", "summary": "Paid camera apps that apply vintage, film, or cinematic color looks to photos and video, aimed at people who want a stylized image without editing.", "heat": "rising", "apps": [ { "name": "Chromagraph Camera", "url": "https://apps.apple.com/us/app/chromagraph-camera/id6803329435", "fact": "29 days old · #1 paid in Photo & Video (DE)" }, { "name": "Very Good Camera", "url": "https://apps.apple.com/us/app/very-good-camera/id6760676546", "fact": "28 days old · #20 paid in Photo & Video (GB)" } ], "people_say": ["Early reviews praise Chromagraph's distinctive image rendering, while some users mention interface issues."], "people_want": ["An Android version of Chromagraph, which reviewers say it lacks."], "posts": [{ "title": "Chromagraph Camera Review", "url": "https://www.youtube.com/watch?v=ey8s3xHnf_c", "where": "YouTube" }], "ideas": 0 } ] } ``` | Field | Description | |---|---| | `day` | The day the radar read, in UTC. | | `read` | How much it read that day: apps, charts, patterns, and patterns people are talking about more. | | `signals[].heat` | `rising`, `steady` or `quiet`: how much people are talking about the pattern. `null` when it was not heard. | | `signals[].apps[].fact` | The app's age and its best place on one store category's chart in one country. A place is never on a store's overall chart. | | `signals[].people_say` | What people say about the pattern, in short sentences. | | `signals[].people_want` | What they ask for that the apps do not give them. | | `signals[].ideas` | How many ideas DECA wrote from this pattern. Read them with [`get_ideas`](https://app.decalabs.ai/docs/tools/get-ideas). | > **Note** · The radar updates once a day. Answers are cached for up to ten minutes. Source: https://app.decalabs.ai/docs/tools/get-signals --- # get_ideas > Consumer product ideas written from the day's signals and judged worth testing, with their evidence. **GET /api/agent/ideas · MCP tool get_ideas · Free** From each strong pattern DECA's engine writes product ideas. A second pass judges each one: what it would take to build, the risks, and the sign-up rate a test can expect. `get_ideas` returns the ideas judged `go` or `maybe` from the last two weeks, best first, with the apps and posts each one rests on. Ideas a founder is testing are not shown, and neither is anything written for one company. ## Parameters | Name | Type | Description | |---|---|---| | `id` | string | One idea's id, to read only that idea. Optional. | | `query` | string | Words that must all appear in the idea. Optional. | | `verdict` | `go` · `maybe` | Only ideas the judge rated this way. Optional. | | `limit` | integer | How many to return, 1 to 25. Default 10. | ## Request ```bash title="cURL" curl "https://app.decalabs.ai/api/agent/ideas?query=tidy&limit=3" ``` ```json title="MCP" { "name": "get_ideas", "arguments": { "query": "tidy", "limit": 3 } } ``` ```bash title="One idea" curl "https://app.decalabs.ai/api/agent/ideas?id=5c33b777-5c0e-4bb6-a2f1-d98dbb71bc21" ``` ## Response ```json { "day": "2026-11-18", "count": 1, "ideas": [ { "id": "5c33b777-5c0e-4bb6-a2f1-d98dbb71bc21", "name": "Drawerly", "one_line": "An app for people who love tidy-up games: photograph a messy drawer or shelf and get a short, step-by-step sorting plan to tick off.", "promise": "Snap your messy drawer and get a ten-minute plan to sort it.", "who": "Women aged 25 to 45 in the US and UK who play cosy organising games and follow tidying content on short video", "what": [ "Take one photo of a drawer, shelf or toy box and the app lists what it sees", "Get five to eight short steps grouped by colour or type, each ticked off with a satisfying sound" ], "why_now": "Tidy Everything! reached the top of a UK free chart in 16 days with a toy store tidying theme…", "first_version": "Camera capture, an image model call that lists items and returns grouped steps, a tick-off checklist…", "risks": ["The model may misread cluttered photos and give steps that feel generic"], "verdict": "maybe", "written": "2026-11-18", "from_signal": "Casual sorting and logic puzzle games", "evidence": { "apps": [{ "name": "Tidy Everything!", "url": "https://apps.apple.com/us/app/tidy-everything/id6824655215", "fact": "16 days old, #1 top free in Family games (GB), #14 top grossing in Family games (GB)" }], "posts": [{ "title": "Why Is Putting Together Virtual Puzzles SO FUN?! - Puzzle Simulator", "url": "https://www.youtube.com/watch?v=ysWmGHnPSC8", "where": "YouTube (Kelly Kas)" }] }, "expected": { "signup_rate": 0.037, "signup_rate_low": 0.022, "signup_rate_high": 0.056, "cost_per_click_usd": 0.77, "basis": "an estimate from our default rates and the judge's reading; no test of this idea has run" }, "build_days": 15, "url": "https://app.decalabs.ai/board/5c33b777-5c0e-4bb6-a2f1-d98dbb71bc21?utm_source=agent&utm_medium=mcp" } ] } ``` | Field | Description | |---|---| | `id` | The idea's id. Pass it to [`quote_test`](https://app.decalabs.ai/docs/tools/quote-test) as `idea_id`. | | `one_line` | The idea in one plain sentence. | | `verdict` | `go` or `maybe`, from the judge. | | `evidence` | The apps and posts the idea rests on. | | `expected` | The share of cold visitors expected to leave their email, with a low and high bound, and the expected cost of a click. An estimate until the idea is tested. | | `build_days` | The judge's estimate of the days to a first version. | | `url` | The idea's page on DECA, for a person to open. | > **Note** · Idea names are written by the engine and can match an existing product by chance. Check a name before you use it in public. Source: https://app.decalabs.ai/docs/tools/get-ideas --- # get_my_ideas > The ideas DECA's engine wrote for your own workspace, each with why it is yours. **GET /api/agent/my-ideas · MCP tool get_my_ideas · Needs a key · Free** `get_ideas` returns what DECA's radar found for everyone. `get_my_ideas` returns what it found for **you**: ideas the engine wrote for your workspace from what it knows about you, and the day's public ideas it picked as the best fit for you, each with the reason. The engine learns about you in the dashboard, under **Settings → Your radar**: your company's site and what you sell, or, for one person, what you can do, spend and care about. New ideas for you arrive every day. ## Private by design - **It needs an API key.** The key says whose ideas to return. Without one the call is refused with `key_required`. - **A key sees only its own workspace.** No call can read another workspace's ideas, profile or picks. - **Read only.** The tool returns what the engine has already written. It never asks the engine to write more; that stays your choice in the dashboard. - **Ideas written for you are never published.** They do not appear in `get_ideas` or on the public board. ## Parameters | Name | Type | Description | |---|---|---| | `include` | `all` · `written` · `picks` | Ideas written for you, the day's picks for you, or both. Default both. | | `limit` | integer | How many of each to return, 1 to 25. Default 10. | ## Request ```bash title="cURL" curl -H "Authorization: Bearer deca_sk_…" \ "https://app.decalabs.ai/api/agent/my-ideas?limit=5" ``` ```json title="MCP" { "name": "get_my_ideas", "arguments": { "limit": 5 } } ``` ## Response ```json { "day": "2026-11-18", "profile": { "state": "ready", "kind": "company", "summary": "A booking platform for hair salons in Germany, with 4,000 salons as customers…" }, "written": [ { "id": "…", "name": "…", "one_line": "…", "why_you": "Your salons already hold their clients' booking history, so…", "verdict": "go", "evidence": { "apps": ["…"], "posts": ["…"] }, "expected": { "signup_rate": 0.034, "…": "…" }, "url": "https://app.decalabs.ai/board/…" } ], "picks": [ { "id": "…", "name": "…", "why": "It sells to the same small businesses you already reach…", "…": "…" } ] } ``` Each idea has the same fields as in [`get_ideas`](https://app.decalabs.ai/docs/tools/get-ideas), plus: | Field | Description | |---|---| | `written[].why_you` | Why the engine wrote this idea for you. | | `picks[].why` | Why this public idea fits you. | | `profile.state` | `none` (not set up yet), `reading` (being made, ideas follow in minutes), `ready` or `failed`. | | `next` | Present when there is something to do first, such as setting up your radar. | An idea written for you can be priced with [`quote_test`](https://app.decalabs.ai/docs/tools/quote-test) by its `id`, with the same key. Source: https://app.decalabs.ai/docs/tools/get-my-ideas --- # quote_test > The price of a ten-day demand test for any idea, as budget options sized to it. **POST /api/agent/quote · MCP tool quote_test · Free** `quote_test` prices a demand test before anything is paid. A test costs **only its ad budget, at cost**, in USDC on Base. DECA adds no fee and no markup. The budget is not one number. DECA sizes a few options to the idea from what it can be expected to do, and each option says what it can and cannot tell. See [How a test is priced](https://app.decalabs.ai/docs/guides/pricing) for the method. ## Parameters | Name | Type | Description | |---|---|---| | `idea_id` | string | An idea's `id` from [`get_ideas`](https://app.decalabs.ai/docs/tools/get-ideas). Use this or `idea`. | | `idea.pitch` | string | Your own idea: who it is for and what it does for them, 20 to 2,000 characters. It is never published. | | `idea.name` | string | A name for your idea. Optional. | | `markets` | array | Where the ads run: `US`, `GB`, `CA`. Default all three. | | `budget_usd` | number | A budget of your own to price alongside the options, from 250 to 2,000. Optional. | ## Request ```bash title="cURL" curl -X POST https://app.decalabs.ai/api/agent/quote \ -H "content-type: application/json" \ -d '{"idea_id": "5c33b777-5c0e-4bb6-a2f1-d98dbb71bc21", "budget_usd": 300}' ``` ```json title="MCP" { "name": "quote_test", "arguments": { "idea_id": "5c33b777-5c0e-4bb6-a2f1-d98dbb71bc21", "budget_usd": 300 } } ``` ```json title="Your own idea" { "idea": { "name": "Pantry", "pitch": "A pantry app that tells families what to cook from what is about to expire" }, "markets": ["US", "GB"] } ``` ## Response ```json { "quote_id": "q1.eyJ2IjoxLCJpZGVhIjoiN…", "expires_at": "2026-11-18T20:24:28.715Z", "currency": "USDC", "network": "base", "fee_usd": 0, "idea": { "id": "5c33b777-5c0e-4bb6-a2f1-d98dbb71bc21", "name": "Drawerly" }, "assumptions": { "signup_rate": 0.037, "cost_per_click_usd": 0.75, "confirm_share": 0.7, "source": "this idea's reading by our engine, with click costs measured in our own ad accounts in 2026" }, "options": [ { "id": "signal", "label": "Signal: is there demand at all", "budget_usd": 450, "markets": ["US", "GB", "CA"], "days": 10, "expected_visits": 600, "pass_line": 16, "first_part": { "usd": 150, "days": 3, "continue_if_at_least": 3 }, "tells": "Whether at least 16 people in US, GB, CA confirm their email for this before it exists. The cheapest budget whose answer is more than noise.", "does_not_tell": "How strong the demand is, or which market wants it most; a near miss could go either way." }, { "id": "clear", "label": "Clear read: a result that rests less on luck", "budget_usd": 900, "expected_visits": 1200, "pass_line": 31, "…": "…" } ], "recommended": "signal", "declined": [ { "id": "yours", "why": "$300 buys about 400 visits; its line would be 10 confirmed people, below the 15 under which a pass is noise. The smallest budget that says something here is $450." } ], "review": { "required": true, "note": null }, "refunds": "Declined at review or cancelled before going live: refunded in full. …", "next": "Pay an option with start_test. Try it first with sandbox: true, on Base Sepolia with test USDC; real tests pay in USDC on Base." } ``` | Field | Description | |---|---| | `quote_id` | A signed id for this quote. Pass it to `start_test` to pay. | | `expires_at` | The quote holds for 30 minutes. | | `assumptions` | The sign-up rate and click cost the options rest on, and where they come from. | | `options[].budget_usd` | What the option costs, all of it ad budget. | | `options[].pass_line` | Confirmed sign-ups the test must reach to pass. Set before the first ad runs and never lowered. | | `options[].pass_line_by_market` | For a market comparison: each market's own line. | | `options[].first_part` | Budgets from $300 run a first part for three days. If it brings fewer than `continue_if_at_least` confirmed sign-ups, the test stops and the rest is refunded. | | `options[].tells` · `does_not_tell` | What this budget can answer, and what it cannot. | | `declined` | Options that were left out, and why: too costly to read reliably, or a budget of yours too small to say anything. | | `review.note` | Set when the idea touches an area ad platforms restrict, such as finance, crypto, health or gambling. Such a test may be declined at review and refunded in full. | The options are: | `id` | When it is offered | |---|---| | `signal` | Always, unless no budget up to $2,000 can read the idea reliably. | | `clear` | When twice the signal budget still fits under $2,000. | | `compare` | When you ask for more than one market and every market's own line fits under $2,000 in total. | | `yours` | When you send `budget_usd` and it can say something. | > **Note** · Over MCP, a quote that cannot offer anything comes back as an error with `code: "no_reliable_option"` and the reasons in `details`. Source: https://app.decalabs.ai/docs/tools/quote-test --- # How a test is priced > Only the ad budget, at cost, sized to what the idea can be expected to do. A DECA test puts an idea in front of cold audiences with ten days of real ads and counts how many people confirm their email for something that does not exist yet. The price of a test is its ad budget, nothing else. DECA makes the brand, the landing page and the ads, runs them and reads the result at no charge. ## Why the budget depends on the idea A test is only worth running if its answer is more than noise. Below **15 confirmed sign-ups**, a pass could be luck. So the question is not "how much do you want to spend" but "how much does it take, for this idea, to reach a line that means something". That depends on two numbers: | | What it is | Where it comes from | |---|---|---| | **Cost per click** | What a visit from paid social to a page costs | Measured in DECA's own Meta ad accounts in 2026 | | **Sign-up rate** | The share of cold visitors who leave their email | 1.5% to 5% for an idea that does not exist yet; the engine's estimate for each idea in `get_ideas` | About **seven in ten** of those who leave an email confirm it, and only confirmed sign-ups count. ## The markets | Market | Cost per click | |---|---| | United States (`US`) | $1.03 | | United Kingdom (`GB`) | $0.86 | | Canada (`CA`) | $0.58 | An idea whose audience costs more or less to reach than average (professionals cost several dollars a click) moves these figures by the engine's estimate for it. Markets we have not measured are not priced yet. ## The options For each idea `quote_test` works out: - **Signal**: the smallest budget whose pass line reaches 15 confirmed sign-ups. The cheapest answer that says something. - **Clear read**: twice the signal budget, so a pass or a miss rests much less on chance. - **Market comparison**: each market gets the budget its own line needs, so the result says which market wants the idea most. - **Yours**: any budget you name, priced the same way. If its line would fall below 15, it is declined with the smallest budget that would work. Budgets run from **$250 to $2,000**. An idea that cannot reach a reliable line within $2,000 is told so rather than sold a test that cannot answer. ### A worked example An idea with the default 3% sign-up rate, across the US, UK and Canada (average click $0.82): 1. 15 confirmed sign-ups need 15 ÷ 0.7 ≈ 21.4 emails. 2. 21.4 emails at 3% need about 714 visits. 3. 714 visits at $0.82 cost about $585, so the signal budget is **$600**. ## The line is set before the first ad The pass line comes with the quote and is recorded on Base before the first ad runs. It can be raised, never lowered. When the test ends, its result is recorded on Base too, so anyone can check that the line was not moved after the fact. ## First part and refunds Budgets from $300 start with a **first part**: $150 over three days. If it brings fewer confirmed sign-ups than half the pace the line needs, the test stops there and the rest is refunded. | What happens | What comes back | |---|---| | Declined at review | Everything | | Cancelled before the ads go live | Everything | | Stopped after the first part | Everything not spent | | Spends less than its budget | Everything not spent | Refunds go to the paying wallet in USDC on Base. ## Review A person reviews every paid test before its ads run. Ideas in areas ad platforms restrict, such as finance, crypto, health, gambling or dating, may be declined. `quote_test` flags them in `review.note`, and a declined test is refunded in full. Source: https://app.decalabs.ai/docs/guides/pricing --- # Paid tests > Pay for a test in USDC on Base over x402, and follow it to its result. Real tests are paid in USDC on Base, for the exact ad budget of the option you pick. Most x402 clients cap a single payment at $1 by default, so raise your client's spend limit before paying for a real test. To build and try the flow first, use the **sandbox**: add `sandbox: true`. It runs the same steps on Base Sepolia for 1 test USDC whatever the budget ([free from Circle's faucet](https://faucet.circle.com)); no ads run and progress is simulated. A test costs its ad budget, nothing more, paid in USDC on Base with [x402](https://x402.org), the HTTP payment standard. Your agent pays the exact amount the quote names, DECA settles it, and a person reviews the idea before its ads run. ## The flow 1. **Quote.** Call [`quote_test`](https://app.decalabs.ai/docs/tools/quote-test) and pick an option. 2. **Ask to pay.** Call `start_test` with the `quote_id` and the option. The answer is `402 Payment Required` with an x402 payment request: the exact amount, the USDC contract, the network and DECA's wallet. 3. **Pay.** Your x402 client signs the payment and sends the same request again with it in the `PAYMENT-SIGNATURE` header (over MCP, as the `payment` argument). 4. **Follow.** The answer is `201` with the test and an `access_token`. Read it with `get_test`, or give a `webhook_url` and be told at every change. ```ts title="TypeScript (REST)" import { x402Client } from "@x402/core/client"; import { x402HTTPClient } from "@x402/core/http"; import { ExactEvmScheme } from "@x402/evm/exact/client"; import { toClientEvmSigner } from "@x402/evm"; import { privateKeyToAccount } from "viem/accounts"; const signer = toClientEvmSigner(privateKeyToAccount(process.env.WALLET_KEY as `0x${string}`)); const client = new x402HTTPClient(x402Client.fromConfig({ schemes: [{ network: "eip155:84532", client: new ExactEvmScheme(signer) }], // eip155:8453 for real tests spendControls: { maxAmountPerPayment: "$2000" }, // x402 clients cap a payment at $1 by default policies: [(v, reqs) => reqs.filter((r) => r.payTo.toLowerCase() === "0x7fb30ed8d7a7b45ee7b98903d94d87d1b9c3dad2")], })); const url = "https://app.decalabs.ai/api/agent/tests"; const body = JSON.stringify({ quote_id, option: "signal", sandbox: true, idempotency_key: crypto.randomUUID() }); const ask = await fetch(url, { method: "POST", headers: { "content-type": "application/json" }, body }); const required = client.getPaymentRequiredResponse((h) => ask.headers.get(h), await ask.json()); const payment = await client.createPaymentPayload(required); const paid = await fetch(url, { method: "POST", headers: { "content-type": "application/json", ...client.encodePaymentSignatureHeader(payment) }, body }); const { test, access_token } = await paid.json(); ``` ```json title="MCP" { "name": "start_test", "arguments": { "quote_id": "q1.…", "option": "signal", "sandbox": true } } ``` > **Warning** · Check `payTo` before you pay. DECA's wallet is `decalabs.base.eth`, `0x7FB30eD8D7a7B45EE7b98903d94D87D1B9C3DaD2`. A request to pay any other address did not come from DECA. ## The payment request ```json { "x402Version": 2, "accepts": [{ "scheme": "exact", "network": "eip155:84532", "amount": "1000000", "asset": "0x036CbD53842c5426634e7929541eC2318f3dCF7e", "payTo": "0x7FB30eD8D7a7B45EE7b98903d94D87D1B9C3DaD2", "maxTimeoutSeconds": 300, "extra": { "name": "USDC", "version": "2" } }], "deca": { "pay": "$1 test USDC", "budget_usd": 600, "network": "Base Sepolia (sandbox)", "option": "signal", "pass_line": 15 } } ``` | | Real | Sandbox | |---|---|---| | Network | Base, `eip155:8453` | Base Sepolia, `eip155:84532` | | USDC | `0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913` | `0x036CbD53842c5426634e7929541eC2318f3dCF7e` | | Charge | The option's budget | 1 test USDC, whatever the budget | | Ads | Real, after review | None; the test moves through its states in about seven minutes, marked `simulated` | ## Safe to retry - **`idempotency_key`**: send the same one again and you get the same test back, never a second charge. Make it a random value of at least 16 characters and keep it: if the answer to a paid request never reaches you, sending the same request (same payment, same key) again returns the test with a new `access_token`. - **A payment that got no answer**: the test waits in `settling`. DECA looks the payment up on Base itself within minutes: paid, it moves to `in_review`; never paid, it is marked `settle_failed` and nothing was charged. - **One payment, one test**: a payment that was already used is refused with `payment_already_used`. - **Caps hold**: with an API key, a test above the key's cap per test (`over_cap`) or per month (`over_month_cap`) is refused before any payment is asked for. ## The states | State | What it means | |---|---| | `settling` | The payment is being settled on Base | | `in_review` | A person is reviewing the idea, usually within one business day | | `building` | DECA is making the brand, the page and the ads | | `live` | The ads are running | | `reading` | The ads have ended and the result is being read | | `done` | The result is in: `pass` or `miss`, confirmed sign-ups against the pass line | | `declined` | Declined at review; the whole budget is refunded | | `cancelled` | Cancelled before the ads ran; the whole budget is refunded | | `settle_failed` | The payment did not go through; nothing was charged | ## Reading a test ```bash title="With a key" curl -H "Authorization: Bearer deca_sk_…" https://app.decalabs.ai/api/agent/tests/TEST_ID ``` ```bash title="With its access token" curl -H "X-Test-Token: deca_tt_…" https://app.decalabs.ai/api/agent/tests/TEST_ID ``` ```bash title="All your tests" curl -H "Authorization: Bearer deca_sk_…" https://app.decalabs.ai/api/agent/tests ``` A test paid with a key also shows in your workspace. A test paid without one is read with the `access_token` returned once by `start_test`. ## Cancelling `POST /api/agent/tests/TEST_ID/cancel` (MCP `cancel_test`) while the test is `in_review`. The whole budget is refunded. ## Refunds Declined, cancelled, stopped after its first part, or under budget: the money not spent on ads goes back to the paying wallet, in USDC on Base. `get_test` shows it under `refund`: `owed`, then `sent` with its transaction. ## Webhooks Send a public `https` `webhook_url` with `start_test`. DECA posts `{ event, test_id, state, at }` at every change, signed in the `deca-signature` header as `sha256=` HMAC of the body with the `webhook_secret` returned once. ## Tools | Tool | REST | What it does | |---|---|---| | `start_test` | `POST /api/agent/tests` | Ask to pay, then pay and open the test | | `get_test` | `GET /api/agent/tests/{id}` | A test's state and everything in it | | `list_my_tests` | `GET /api/agent/tests` | Every test paid with your key's workspace | | `cancel_test` | `POST /api/agent/tests/{id}/cancel` | Cancel before review ends, with a full refund | Source: https://app.decalabs.ai/docs/guides/paid-tests --- # Score an idea for 1 USDC > One call, one USDC on Base over x402, and your own idea comes back scored against live app-store demand. The smallest thing an agent can buy from DECA: send an idea, pay one USDC, and get back a verdict with the reason, the closest apps already on the charts, the sign-ups a $500 ad test should bring, and the smallest budget that would give a real answer. There is no quote step and no key. The price is fixed, and you are charged only when a score comes back. :::endpoint POST /api/agent/score · REST only · 1 USDC ## The flow 1. **Ask.** `POST /api/agent/score` with no payment answers `402 Payment Required`: one USDC on Base, to DECA's wallet. 2. **Pay and send.** Your [x402](https://x402.org) client signs the payment and sends the same request again with it in the `PAYMENT-SIGNATURE` header, with the idea in the body. 3. **Read.** The answer is `200` with the score and the payment's transaction. ```json title="Request body" { "idea": { "name": "Petsitter", "pitch": "An app for dog owners in big cities to find a vetted sitter for the same evening, with live photo updates during the visit." } } ``` ```json title="Answer (example)" { "score": { "name": "Petsitter", "summary": "A phone app that finds a vetted dog sitter for tonight and sends photos during the visit.", "verdict": "maybe", "reason": "It works if owners trust a sitter they have not met; the closest apps are rated down for no-shows.", "expected_signups_at_500_usd": 21, "signup_rate_to_pass_pct": 2.4, "smallest_useful_budget_usd": 500, "closest_apps": ["Rover", "Wag!"] }, "paid": { "usd": 1, "network": "Base", "tx": "0x…" } } ``` `pitch` is 20 to 2,000 characters: who the product is for and what it does for them. `name` is optional. `verdict` is `go`, `maybe` or `hold`. ## What you are not charged for - A request with no payment, or with a body that is not an idea. - An idea the engine could not score. The answer says so and the payment is not settled. - The same payment sent twice. It returns the score it already bought. ## Sandbox Add `?sandbox=1` to run the same exchange on Base Sepolia for one test USDC ([free from Circle's faucet](https://faucet.circle.com)). The sandbox answers with a fixed example and does not run the engine. ## Then test it A score is a forecast. To learn what real people do, pass the same pitch to [`quote_test`](https://app.decalabs.ai/docs/tools/quote-test) and follow [Paid tests](https://app.decalabs.ai/docs/guides/paid-tests). Source: https://app.decalabs.ai/docs/guides/score-idea --- # REST API > The same tools as plain HTTPS endpoints, for agents and code that do not speak MCP. Every MCP tool is also a plain endpoint. Requests and answers are JSON, and an answer is the same object the MCP tool returns. | | | |---|---| | **Base URL** | `https://app.decalabs.ai` | | **Format** | JSON in, JSON out | | **Authentication** | Optional `Authorization: Bearer` key. See [Authentication](https://app.decalabs.ai/docs/reference/authentication). | | **CORS** | Open to any origin | | **OpenAPI** | [`/api/agent/openapi.json`](https://app.decalabs.ai/api/agent/openapi.json) | ## Endpoints | Method | Path | Tool | |---|---|---| | `GET` | `/api/agent/signals` | [`get_signals`](https://app.decalabs.ai/docs/tools/get-signals) | | `GET` | `/api/agent/ideas` | [`get_ideas`](https://app.decalabs.ai/docs/tools/get-ideas) | | `GET` | `/api/agent/my-ideas` | [`get_my_ideas`](https://app.decalabs.ai/docs/tools/get-my-ideas) (needs a key) | | `POST` | `/api/agent/quote` | [`quote_test`](https://app.decalabs.ai/docs/tools/quote-test) | | `POST` | `/api/agent/score` | [Score an idea](https://app.decalabs.ai/docs/guides/score-idea), 1 USDC over x402 (REST only) | | `POST` | `/api/agent/tests` | `start_test`, paid over x402: see [Paid tests](https://app.decalabs.ai/docs/guides/paid-tests) | | `GET` | `/api/agent/tests` | `list_my_tests` (needs a key) | | `GET` | `/api/agent/tests/{id}` | `get_test` | | `POST` | `/api/agent/tests/{id}/cancel` | `cancel_test` | `GET` endpoints take their parameters in the query string. `POST` endpoints take a JSON object in the body with `content-type: application/json`. ## Status codes | Code | When | |---|---| | `200` | The call worked | | `201` | A paid test was opened | | `202` | The payment was sent but its settlement has not answered yet; read the test again | | `400` | Something in the request is wrong; the body says what | | `401` | The API key is not valid or was revoked | | `402` | Payment required: the body and the `PAYMENT-REQUIRED` header carry the x402 request | | `403` | The API key may not use this tool | | `404` | No idea or endpoint by that name | | `405` | The wrong method for the endpoint | | `409` | The payment or the idempotency key was already used | | `422` | The text sent to be scored is not a product idea; nothing was charged | | `429` | Too many requests; wait for `Retry-After` seconds | | `503` | The radar, the scoring engine or the payment service is not available right now; nothing was charged | Every non-`200` answer has the [error shape](https://app.decalabs.ai/docs/reference/errors). ## Caching `GET` answers may be cached for five minutes (`Cache-Control: public, s-maxage=300`). The radar itself changes once a day. Source: https://app.decalabs.ai/docs/reference/rest --- # Errors > Every error has a code, a message and the next step, so an agent can recover on its own. When a call cannot be answered, DECA returns an error object instead of a result. Over REST it comes with a non-`200` status. Over MCP the tool result has `isError: true` and the same object in `structuredContent`. ```json { "error": { "code": "market_not_supported", "message": "We only price markets where we have measured what a click costs: US, GB, CA. Not: DE.", "next": "use markets from US, GB, CA" } } ``` | Field | Description | |---|---| | `code` | A stable identifier. Branch on this, never on the message. | | `message` | What went wrong, in a sentence a person or a model can read. | | `next` | What to do about it. Present when there is something to do. | | `details` | More about the error, such as the reasons a quote declined each option. Optional. | ## Codes | Code | Status | What it means | What to do | |---|---|---|---| | `idea_missing` | 400 | `quote_test` got neither `idea_id` nor `idea.pitch` | Send one of them | | `idea_too_short` | 400 | `idea.pitch` is under 20 characters | Say who it is for and what it does for them | | `idea_too_long` | 400 | `idea.pitch` is over 2,000 characters | Shorten it | | `idea_not_found` | 404 | No public idea has that id | Call `get_ideas` again; ideas leave after two weeks or when a founder takes them | | `market_not_supported` | 400 | A market DECA has not priced | Use `US`, `GB` or `CA` | | `no_reliable_option` | 400 | No budget up to $2,000 can read this idea reliably | Try other markets, or sharpen the idea; reasons in `details` | | `radar_unavailable` | 503 | The radar has nothing to show | Try again in a few minutes | | `key_required` | 401 | The tool needs an API key, such as `get_my_ideas` | Make a key in MCP & API | | `invalid_key` | 401 | The API key is not one DECA made | Check it, or call without a key | | `key_revoked` | 401 | The API key was revoked | Make a new one in MCP & API | | `scope_missing` | 403 | The key may not use this tool | Add the scope to the key | | `quote_invalid` · `quote_expired` | 400 | The quote is not DECA's, or older than 30 minutes | Call `quote_test` again | | `option_not_in_quote` | 400 | The quote has no such option | Use one of its options | | `payments_not_open` | 503 | Real payments are switched off for the moment | Use the sandbox | | `idea_invalid` | 400 | `POST /api/agent/score` got no `idea.pitch` of 20 to 2,000 characters; nothing was charged | Send `{ idea: { pitch } }` | | `not_an_idea` | 422 | The text sent to be scored is not a product idea; nothing was charged | Say who it is for and what it does | | `engine_unavailable` · `score_failed` | 503 | The idea could not be scored this time; nothing was charged | Try again in a few minutes | | `payments_unavailable` | 503 | The payment service could not be reached; nothing was charged | Retry later, or use `sandbox: true` | | `payment_invalid` | 402 | The payment does not match the request, or was refused | Pay the exact request again | | `payment_failed` | 402 | The payment could not be settled; nothing was charged | Check the wallet's balance | | `payment_already_used` | 409 | That payment already opened a test or bought a score | Read the test, or pay again | | `idempotency_key_used` | 409 | The idempotency key belongs to another payment | Use a new key for a new test | | `over_cap` · `over_month_cap` | 403 | Above the key's cap per test or per month | A smaller option, or a higher cap | | `webhook_invalid` | 400 | `webhook_url` is not a public https address | Fix it or leave it out | | `test_not_found` | 404 | No test you can read has that id | Send the key or the access token | | `cannot_cancel` | 409 | The test is past review | Write to hello@decalabs.ai | | `rate_limited` | 429 | Too many requests from this address | Wait for `Retry-After` seconds | | `bad_json` | 400 | The body is not a JSON object | Send `content-type: application/json` with an object | | `wrong_method` | 405 | `GET` where `POST` is needed, or the reverse | Use the method in `Allow` | | `unknown_tool` | 404 | No tool or endpoint by that name | Use one listed in [the overview](https://app.decalabs.ai/docs) | New codes may be added. Treat a code you do not know as a failure with its `message`. ## Protocol errors Over MCP, a request that is not valid JSON-RPC gets a JSON-RPC error instead: `-32700` parse error, `-32600` invalid request, `-32601` method not found, `-32602` unknown tool, `-32603` internal error, `-32000` too many requests, `-32001` API key refused (code in `data.code`). Source: https://app.decalabs.ai/docs/reference/errors --- # Rate limits > How many calls an address can make, and how to tell where it stands. The free tools are open to anyone, so each address is limited to **60 calls a minute** across MCP and REST. Calls made with an [API key](https://app.decalabs.ai/docs/reference/authentication) are limited per key instead, to **600 a minute**. Every answer says where you stand: | Header | Meaning | |---|---| | `RateLimit-Limit` | Calls allowed in a minute | | `RateLimit-Remaining` | Calls left in this minute | | `RateLimit-Reset` | Seconds until the minute starts again | | `Retry-After` | On a `429` only: seconds to wait | A call over the limit gets `429` with the error code `rate_limited` over REST, or JSON-RPC error `-32000` over MCP. Over MCP, a JSON-RPC batch may hold at most **20 messages**, and every tool call inside it counts as one call. ## Staying under it - **Cache.** Signals and ideas change once a day. Reading them once and keeping them is enough. - **Narrow.** Use `query`, `heat`, `verdict` and `limit` instead of reading everything and filtering yourself. - **Back off.** On a `429`, wait for `Retry-After` before trying again. For a higher limit, use an [API key](https://app.decalabs.ai/docs/reference/authentication). Source: https://app.decalabs.ai/docs/reference/limits --- # Authentication > Every tool works without a key. An API key ties an agent's calls to your DECA workspace. Every tool works with no key and no account; calls are then limited by address (see [Rate limits](https://app.decalabs.ai/docs/reference/limits)). An **API key** ties an agent's calls to your DECA workspace. | | No key | With a key | |---|---|---| | `get_signals`, `get_ideas`, `quote_test` | Yes | Yes, within the key's scopes | | `get_my_ideas`: ideas written for your workspace | No | Yes, your workspace's only | | Rate limit | 60 calls a minute per address | 600 calls a minute per key | | Calls counted in your dashboard | No | Yes, per key and per tool | | Spending caps on quotes | No | Yes | | Paid tests | Yes, paid in USDC over x402 | Yes, within the key's caps | ## Make a key In the DECA dashboard, open **MCP & API** at the bottom of the menu and press **New key**. Only the workspace's owner can make keys. - **Name** it after the agent that will use it. - **Choose what it may do**: `read` (signals and ideas), `quote` (price tests) and `test` (pay for and run tests, once they open). - **Set its caps**: the most it may spend on one test, and in a month. An agent cannot raise them. The key is shown **once**, when it is made. DECA keeps only a hash of it. If a key is lost or leaked, revoke it and make another. Keys look like `deca_sk_` followed by 40 letters and digits. ## Send it As a bearer token, over MCP or REST: ```bash title="Claude Code" claude mcp add --transport http deca https://app.decalabs.ai/mcp \ --header "Authorization: Bearer deca_sk_…" ``` ```json title="MCP config" { "mcpServers": { "deca": { "type": "http", "url": "https://app.decalabs.ai/mcp", "headers": { "Authorization": "Bearer deca_sk_…" } } } } ``` ```bash title="REST" curl -H "Authorization: Bearer deca_sk_…" \ "https://app.decalabs.ai/api/agent/ideas?limit=3" ``` Keep keys out of code you share and out of public repositories. Pass them through your client's secret or environment settings. ## Caps on quotes With a key that has a cap per test, every option `quote_test` returns carries `within_cap`, and the answer has a `key_cap` object, so the agent can pick an option it may pay for: ```json { "options": [ { "id": "signal", "budget_usd": 450, "within_cap": true, "…": "…" }, { "id": "clear", "budget_usd": 900, "within_cap": false, "…": "…" } ], "key_cap": { "per_test_usd": 500, "per_month_usd": 1500, "note": "Options above $500 are over this key's cap per test; its owner can raise it in MCP & API." } } ``` ## When a key is refused | Code | Status | Meaning | |---|---|---| | `invalid_key` | 401 | The key is not one DECA made. Check it, or call without a key. | | `key_revoked` | 401 | The key was revoked. Make a new one. | | `scope_missing` | 403 | The key may not use this tool. Add the scope in the dashboard. | A key that is sent must be good: a bad key is refused, never treated as no key. Over MCP these come back as JSON-RPC error `-32001` with the code in `data.code`. ## Without a key, later Paid tests will also work with no key: the wallet that pays a test owns it and reads it by signing with that wallet. Source: https://app.decalabs.ai/docs/reference/authentication --- # Changelog > What changed in DECA's tools for agents, newest first. ## 20 November 2026 · v1.4.0 - **Score an idea for 1 USDC**: `POST /api/agent/score` reads your own idea against live app-store demand and answers with a verdict, the closest apps and the sign-ups to expect. Fixed price, no quote, no key; charged only when a score comes back. See [Score an idea](https://app.decalabs.ai/docs/guides/score-idea). - The score endpoint carries the x402 Bazaar discovery block, so marketplaces that read it can list and call it. - DECA is in the official MCP Registry as `ai.decalabs/deca`. - The OpenAPI document now describes the paid endpoints too: `/api/agent/score` and `/api/agent/tests`. - New errors: `idea_invalid`, `not_an_idea`, `engine_unavailable`, `score_failed`. ## 19 November 2026 · v1.3.2 - The rate limit is now counted across all of DECA's servers, so the numbers in the `RateLimit-*` headers are exact. - A webhook is sent only to a public address, checked when it is sent. ## 19 November 2026 · v1.3.1 - **Real payments are open** on Base. The sandbox stays for building. - **A payment that got no answer is never lost**: a test left in `settling` is looked up on Base and moved on; a repeated request with the same payment and `idempotency_key` returns the test with a new `access_token`. - **Stricter keys over REST**: reading tests needs the `read` scope and cancelling needs `test`, as over MCP. - **Refunds of unspent budget** are recorded the moment a test ends. - MCP batches hold at most 20 messages, each tool call counted. Webhooks no longer follow redirects. New errors: `payments_unavailable`, `idempotency_key_used`. ## 18 November 2026 · v1.3.0 - **Paid tests over x402**: `start_test` answers with an x402 v2 payment request for the exact ad budget in USDC; paying it opens the test, reviewed by a person before its ads run. `get_test`, `list_my_tests`, `cancel_test`, webhooks, idempotency keys and key caps. Runs in the sandbox on Base Sepolia, and for real in USDC on Base. ## 18 November 2026 · v1.2.0 - **`get_my_ideas`**: the ideas DECA's engine wrote for your own workspace, each with why it is yours, and the day's public ideas picked for you. Needs an API key; a key sees only its own workspace. Read only. - `quote_test` prices an idea written for your workspace by its `id`, with the same key. ## 18 November 2026 · v1.1.0 - **API keys**, made in the dashboard under MCP & API. Sent as `Authorization: Bearer`, over MCP or REST. Scopes (`read`, `quote`, `test`), caps per test and per month, 600 calls a minute per key, and calls counted per key. - `quote_test` marks each option `within_cap` and adds `key_cap` when the key has a cap. - New error codes: `invalid_key`, `key_revoked`, `scope_missing`. ## 18 November 2026 · v1.0.0 The first release. - **MCP server** at `https://app.decalabs.ai/mcp`: streamable HTTP, JSON answers, no key. - **`get_signals`**: the day's demand patterns, with the apps, what people say and want, and the posts behind them. - **`get_ideas`**: ideas judged worth testing, with their evidence and expected sign-up rate. - **`quote_test`**: the price of a ten-day demand test as options sized to the idea. Only the ad budget, at cost, in USDC on Base. - **REST** under `/api/agent`, an **OpenAPI** description, and these docs, each page also as Markdown, with `/llms.txt` and `/llms-full.txt`. Source: https://app.decalabs.ai/docs/reference/changelog