# Business Idea Validator MCP Server (`pxlbyt-co/idea-validator-mcp`) Actor Validate business ideas with live web research, competitor discovery, demand signals, and a scored go or no-go recommendation. Includes `validate-idea` ($0.25) and `quick-check` ($0.05) for founders, side-project builders, and agent workflows. - **URL**: https://apify.com/pxlbyt-co/idea-validator-mcp.md - **Developed by:** [PixelByte Labs](https://apify.com/pxlbyt-co) (community) - **Categories:** MCP servers, AI - **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, NaN bookmarks - **User rating**: No ratings yet ## Pricing from $250.00 / 1,000 full idea validations This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage. Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event ## What's an Apify Actor? Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases. In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours, and optionally produces a well-defined JSON output, datasets with results, or files in key-value store. In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server. Actors are written with capital "A". ## How to integrate an Actor? If asked about integration, you help developers integrate Actors into their projects. You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready. The best way to integrate Actors is as follows. In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md): ```bash npm install apify-client ``` In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md): ```bash pip install apify-client ``` In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md): ````bash # MacOS / Linux curl -fsSL https://apify.com/install-cli.sh | bash # Windows irm https://apify.com/install-cli.ps1 | iex ```bash In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md). If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md). For usage examples, see the [API](#api) section below. For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt). # README ## Business Idea Validator — AI-Powered Idea Validation MCP Server ### What is the Business Idea Validator? The **Business Idea Validator** is an MCP server that validates any business idea with live market research and a structured scoring framework. Give it your idea, target customer, and revenue model, and it returns a scored report with a clear **go/no-go recommendation** in seconds. It is built for **Claude Code, Claude Desktop, OpenClaw, Cursor, and other MCP workflows** where you want one focused validation call instead of a long manual research loop. It also fits automation-adjacent workflows well: screen a new idea with one quick MCP call, then only spend more agent time if the idea survives first contact. Unlike asking an LLM to "evaluate my idea" and getting a vague encouraging essay back, this tool enforces an **8-dimension scoring framework** that catches blind spots, detects kill signals, and won't sugarcoat a bad idea. 🔍 **Live market research** — performs real web searches for competitors, demand signals, pricing intel, and market context. 📊 **Structured scoring** — composite score (0-10) across 8 weighted dimensions. 🚫 **Kill signal detection** — flags ToS violations, market saturation, legal risks. 💰 **Zero-budget path** — every validation includes a realistic $0-start strategy. ### What can this Idea Validator do? - ✅ **Full idea validation** — 8-dimension scorecard with evidence-based analysis, risk flags, and a scored go/no-go verdict - ✅ **Quick preliminary filter** — fast viability check to screen ideas before committing time to a full validation - ✅ **Live competitor discovery** — searches for existing solutions, pricing, and market players - ✅ **Demand signal detection** — scans Reddit, Indie Hackers, and community discussions for real demand evidence - ✅ **Pricing intelligence** — finds what competitors charge to validate your pricing assumptions - ✅ **Risk profiling** — identifies regulatory, technical, and market risks specific to your idea - ✅ **Works via MCP** — connect from Claude Code, Claude Desktop, OpenClaw, Cursor, Windsurf, or any MCP client - ✅ **Fits multi-agent workflows** — let one agent validate the idea, then hand the structured output to another agent for positioning, pricing, or GTM work Built on the **Apify platform**, which means you get API access, scheduling, monitoring, and webhook integrations. Run validations programmatically, batch-validate a list of ideas, or trigger validations from your workflow tools without spinning up a separate research process. ### What data does the Idea Validator extract? | Data Point | Description | |-----------|-------------| | Market Demand Score | Evidence of real customer demand (20% weight) | | Competition Analysis | Number, strength, and pricing of existing players (15%) | | Feasibility Assessment | Can this actually be built with available resources? (15%) | | Time to Revenue | How fast can this generate income? (15%) | | Defensibility Rating | Can competitors easily copy this? (10%) | | Scalability Score | Does this grow beyond trading time for money? (10%) | | Risk Profile | Regulatory, legal, market, and technical risks (10%) | | Zero-Budget Path | Is there a realistic way to start with $0? (5%) | | Composite Score | Weighted average (0-10) with verdict | | Kill Signals | Hard stops — ToS violations, legal issues, scams | | Competitor List | Real competitors found via live web search | | Demand Evidence | Actual community discussions and search signals | #### Verdict scale | Score | Verdict | Meaning | |-------|---------|---------| | ≥ 7.5 | 🟢 Strong | Go build it | | 6.0–7.4 | 🟡 Promising | Explore with caution | | 4.0–5.9 | 🔴 Weak | Deprioritize | | < 4.0 | ⛔ Pass | Move on | ### How to validate a business idea with MCP 1. **Connect this Actor** to your MCP client (Claude Code, Claude Desktop, OpenClaw, Cursor, Windsurf, or any MCP-compatible tool) 2. **Ask your AI assistant** to validate an idea — e.g. "Validate this idea: a Chrome extension that tracks competitor pricing for Shopify sellers" 3. **Provide details** — target customer and revenue model. The more specific, the better the analysis. 4. **Review the report** — scored breakdown, risk flags, competitor analysis, and a clear recommendation 5. **Iterate** — refine your idea based on the feedback, then re-validate #### Example workflow: stop the idea-research loop One practical Claude-style workflow: 1. A new idea lands in Claude Code, Claude Desktop, or another agent workflow 2. Your assistant calls `quick-check` to screen for obvious blockers 3. If the idea survives, it calls `validate-idea` once for the full scorecard 4. A second agent uses the structured output to draft positioning, MVP scope, or a landing-page test That replaces a longer loop of separate prompts for competitors, pricing, demand threads, and risks. The expensive part stays focused, and the rest of the workflow can build on structured output instead of redoing the research from scratch. You can also use the API directly: ```` POST https://YOUR\_USERNAME--idea-validator-mcp.apify.actor/mcp ``` ### MCP Tools #### `validate-idea` — Full Validation ($0.25) Complete structured analysis with live web research. **Input:** | Parameter | Required | Description | |-----------|----------|-------------| | `idea` | ✅ | One-sentence description of your product/service | | `targetCustomer` | ✅ | Who specifically would buy this? | | `revenueModel` | ✅ | How will it make money? | | `budget` | Optional | Starting capital (default: $0) | | `context` | Optional | Your skills, assets, or constraints | **What it does:** Runs 4 parallel web searches (competitors, demand signals from Reddit/IndieHackers, market context, pricing intel), scores across 8 dimensions, detects kill signals, and returns a full markdown report. #### `quick-check` — Fast Filter ($0.05) Lightweight preliminary screen. Use this to filter 10 ideas down to 2-3 worth a full validation. **Input:** | Parameter | Required | Description | |-----------|----------|-------------| | `idea` | ✅ | Brief description of the idea | | `targetCustomer` | Optional | Who would buy this? | **What it does:** Runs 1 web search, checks for obvious blockers, returns a quick viability assessment with key questions to investigate. ### How much does idea validation cost? | Tool | Price | Brave Search Cost | Total | |------|-------|-------------------|-------| | `validate-idea` | $0.25 | ~$0.02 (4 searches) | ~$0.27 | | `quick-check` | $0.05 | ~$0.005 (1 search) | ~$0.055 | **Compare this to alternatives:** - Hiring a consultant for market validation: $500-5,000 - Fiverr market research gig: $25-100 - Spending 2 weeks building the wrong thing: priceless For less than $0.30, you get a structured, evidence-based assessment with live market data. In practice, it is often cheaper than burning a longer agent session on manual competitor, pricing, and demand checks. Validate 10 ideas for under $3. Apify's **free tier includes $5/month** in platform credits — enough for ~18 full validations per month at zero cost. ### Example output **Input:** > Idea: A Chrome extension that tracks competitor pricing changes for e-commerce sellers > Target: Shopify store owners doing $10K-100K/month > Revenue: $29/month subscription **Output (abbreviated):** ``` ### Idea Validation Report #### Scores | Dimension | Score | Notes | |--------------------|-------|------------------------------------| | Market Demand | 7.5 | Strong Reddit signals, Shopify forums active | | Competition | 5.0 | Prisync, Competera exist but target enterprise | | Feasibility | 8.0 | Chrome extension, well-documented APIs | | Time to Revenue | 7.0 | MVP in 2-4 weeks, freemium viable | | Defensibility | 4.0 | Low barrier to copy | | Scalability | 7.5 | SaaS model scales well | | Risk Profile | 6.0 | Chrome Web Store policies, scraping legality | | Zero-Budget Path | 7.0 | Free tier + ProductHunt launch | #### Composite Score: 6.6 / 10 — 🟡 PROMISING #### Kill Signals: None detected #### Risk Flags: - ⚠️ Chrome Web Store review can take 2-4 weeks - ⚠️ Price scraping may violate some retailer ToS #### Verdict: Promising but vulnerable on defensibility. Build an MVP to test demand, but plan for differentiation beyond basic price tracking. ```` ### Why use this instead of other validation tools? There are several idea validation tools out there (WorthBuild, IdeaProof, Validator AI, ProductGapHunt). Here's why this one exists: | | This Tool | Web-Based Validators | |---|---|---| | **Price** | $0.25 per validation | $5-19+ per validation | | **Interface** | MCP — works inside ChatGPT, Claude, Cursor, and other AI workflows | Web forms only | | **Data** | Live web searches per query | Pre-analyzed or LLM-only | | **Batch** | Validate 20 ideas for $5 via API | One at a time, manually | | **Integration** | API + MCP + Apify scheduling | Copy/paste results | | **Kill signals** | Explicit ToS/legal/scam detection | Not a focus | This tool is built for **developers and builders who live in Claude Code, OpenClaw, Cursor, or another MCP-enabled workflow**. If you want a polished web dashboard with financial projections, other tools do that well. If you want fast, cheap, programmable validation inside your existing AI workflow, that is our lane. ### Trust and transparency This tool is deliberately opinionated about trust: - **Live research is explicit.** When `BRAVE_API_KEY` is configured, the tool uses live search for competitors, pricing, and demand evidence. - **Missing live search is explicit too.** If live research is unavailable, the output says so clearly instead of pretending the market is empty. - **Structured output beats vague reassurance.** The goal is not to flatter your idea. It is to show the score, the evidence, the risks, and the kill signals in a format you can inspect. That matters more in an AI workflow, where a long chat can sound confident while quietly making things up. ### How this differs from IdeaBrowser and other web validators - **IdeaBrowser** is great for browsing curated opportunities and trend-tracking. This tool is for **validating your specific idea inside the workflow where you are already building**. - **WorthBuild / IdeaProof / Validator AI** are web-form products. This tool is **MCP-native**, cheaper per run, and easier to chain into Claude Code or OpenClaw workflows. - The core job here is not "give me startup inspiration." It is "tell me fast if this specific bet looks weak, risky, saturated, or worth pursuing." ### Why use this instead of asking your assistant directly? LLMs are great at brainstorming but terrible at honest evaluation: | Problem | What assistants usually do | What This Tool Does | |---------|-------------|-------------------| | Sycophancy | Agree with whatever you suggest | Scores objectively against a fixed framework | | Fictional data | Invent market statistics | Runs live web searches for real evidence | | Missing kill signals | Skip ToS violations, saturation | Actively scans for blockers and red flags | | No structure | Rambling paragraphs that are hard to compare | 8-dimension scorecard with weighted composite | | No consistency | Different answer every time | Same framework, comparable scores across ideas | ### Setup — Brave Search API key For live market research (strongly recommended), set `BRAVE_API_KEY` in Environment Variables: 1. Get a free API key at [brave.com/search/api](https://brave.com/search/api/) — includes $5/month credits (~1,000 searches) 2. In Apify Console → this Actor → Settings → Environment Variables → add `BRAVE_API_KEY` Without the key, tools still return structured analysis using the scoring framework, but they explicitly mark live research as unavailable instead of pretending the market is empty. ### Optional setup — AI synthesis For provider-agnostic AI synthesis, configure either: #### Preferred generic config - `LLM_PROVIDER` = `openai` or `anthropic` - `LLM_API_KEY` - `LLM_MODEL` - `LLM_BASE_URL` (optional, for custom / compatible runtimes) #### Backward-compatible provider-specific config - `OPENAI_API_KEY`, `OPENAI_MODEL`, `OPENAI_BASE_URL` - or `ANTHROPIC_API_KEY`, `ANTHROPIC_MODEL` If no AI provider is configured, the validator still works in heuristic-only mode. ### FAQ **Can I validate multiple ideas in one run?** Each tool call validates one idea. To compare ideas, run `validate-idea` on each and compare composite scores. Use `quick-check` to filter first — it's 5x cheaper. **How accurate is the scoring?** The framework catches structural problems (no demand, saturated market, defensibility gaps) reliably. It's not a crystal ball — it's a structured checklist that asks the questions founders often skip. **What if I disagree with the score?** Read the evidence. Each dimension includes notes explaining the score. If the evidence is wrong or incomplete, add more context and re-run. **Is my idea data stored?** No. Inputs and outputs are processed in your Apify run and not stored beyond your own run history. ### Related tools - [Competitive Intelligence MCP Server](https://apify.com/YOUR_USERNAME/competitive-intel-mcp) — Deep-dive competitive analysis for markets you're considering entering # Actor input Schema ## Actor input object example ```json {} ```` # API You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup. ## JavaScript example ```javascript import { ApifyClient } from 'apify-client'; // Initialize the ApifyClient with your Apify API token // Replace the '' with your token const client = new ApifyClient({ token: '', }); // Prepare Actor input const input = {}; // Run the Actor and wait for it to finish const run = await client.actor("pxlbyt-co/idea-validator-mcp").call(input); // Fetch and print Actor results from the run's dataset (if any) console.log('Results from dataset'); console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`); const { items } = await client.dataset(run.defaultDatasetId).listItems(); items.forEach((item) => { console.dir(item); }); // 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs ``` ## Python example ```python from apify_client import ApifyClient # Initialize the ApifyClient with your Apify API token # Replace '' with your token. client = ApifyClient("") # Prepare the Actor input run_input = {} # Run the Actor and wait for it to finish run = client.actor("pxlbyt-co/idea-validator-mcp").call(run_input=run_input) # Fetch and print Actor results from the run's dataset (if there are any) print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"]) for item in client.dataset(run["defaultDatasetId"]).iterate_items(): print(item) # 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start ``` ## CLI example ```bash echo '{}' | apify call pxlbyt-co/idea-validator-mcp --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "command": "npx", "args": [ "mcp-remote", "https://mcp.apify.com/?tools=pxlbyt-co/idea-validator-mcp", "--header", "Authorization: Bearer " ] } } } ``` ## OpenAPI specification ```json { "openapi": "3.0.1", "info": { "title": "Business Idea Validator MCP Server", "description": "Validate business ideas with live web research, competitor discovery, demand signals, and a scored go or no-go recommendation. Includes `validate-idea` ($0.25) and `quick-check` ($0.05) for founders, side-project builders, and agent workflows.", "version": "1.0", "x-build-id": "Frc0w664PKQFkCz5N" }, "servers": [ { "url": "https://api.apify.com/v2" } ], "paths": { "/acts/pxlbyt-co~idea-validator-mcp/run-sync-get-dataset-items": { "post": { "operationId": "run-sync-get-dataset-items-pxlbyt-co-idea-validator-mcp", "x-openai-isConsequential": false, "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.", "tags": [ "Run Actor" ], "requestBody": { "required": true, "content": { "application/json": { "schema": { "$ref": "#/components/schemas/inputSchema" } } } }, "parameters": [ { "name": "token", "in": "query", "required": true, "schema": { "type": "string" }, "description": "Enter your Apify token here" } ], "responses": { "200": { "description": "OK" } } } }, "/acts/pxlbyt-co~idea-validator-mcp/runs": { "post": { "operationId": "runs-sync-pxlbyt-co-idea-validator-mcp", "x-openai-isConsequential": false, "summary": "Executes an Actor and returns information about the initiated run in response.", "tags": [ "Run Actor" ], "requestBody": { "required": true, "content": { "application/json": { "schema": { "$ref": "#/components/schemas/inputSchema" } } } }, "parameters": [ { "name": "token", "in": "query", "required": true, "schema": { "type": "string" }, "description": "Enter your Apify token here" } ], "responses": { "200": { "description": "OK", "content": { "application/json": { "schema": { "$ref": "#/components/schemas/runsResponseSchema" } } } } } } }, "/acts/pxlbyt-co~idea-validator-mcp/run-sync": { "post": { "operationId": "run-sync-pxlbyt-co-idea-validator-mcp", "x-openai-isConsequential": false, "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.", "tags": [ "Run Actor" ], "requestBody": { "required": true, "content": { "application/json": { "schema": { "$ref": "#/components/schemas/inputSchema" } } } }, "parameters": [ { "name": "token", "in": "query", "required": true, "schema": { "type": "string" }, "description": "Enter your Apify token here" } ], "responses": { "200": { "description": "OK" } } } } }, "components": { "schemas": { "inputSchema": { "type": "object", "properties": {} }, "runsResponseSchema": { "type": "object", "properties": { "data": { "type": "object", "properties": { "id": { "type": "string" }, "actId": { "type": "string" }, "userId": { "type": "string" }, "startedAt": { "type": "string", "format": "date-time", "example": "2025-01-08T00:00:00.000Z" }, "finishedAt": { "type": "string", "format": "date-time", "example": "2025-01-08T00:00:00.000Z" }, "status": { "type": "string", "example": "READY" }, "meta": { "type": "object", "properties": { "origin": { "type": "string", "example": "API" }, "userAgent": { "type": "string" } } }, "stats": { "type": "object", "properties": { "inputBodyLen": { "type": "integer", "example": 2000 }, "rebootCount": { "type": "integer", "example": 0 }, "restartCount": { "type": "integer", "example": 0 }, "resurrectCount": { "type": "integer", "example": 0 }, "computeUnits": { "type": "integer", "example": 0 } } }, "options": { "type": "object", "properties": { "build": { "type": "string", "example": "latest" }, "timeoutSecs": { "type": "integer", "example": 300 }, "memoryMbytes": { "type": "integer", "example": 1024 }, "diskMbytes": { "type": "integer", "example": 2048 } } }, "buildId": { "type": "string" }, "defaultKeyValueStoreId": { "type": "string" }, "defaultDatasetId": { "type": "string" }, "defaultRequestQueueId": { "type": "string" }, "buildNumber": { "type": "string", "example": "1.0.0" }, "containerUrl": { "type": "string" }, "usage": { "type": "object", "properties": { "ACTOR_COMPUTE_UNITS": { "type": "integer", "example": 0 }, "DATASET_READS": { "type": "integer", "example": 0 }, "DATASET_WRITES": { "type": "integer", "example": 0 }, "KEY_VALUE_STORE_READS": { "type": "integer", "example": 0 }, "KEY_VALUE_STORE_WRITES": { "type": "integer", "example": 1 }, "KEY_VALUE_STORE_LISTS": { "type": "integer", "example": 0 }, "REQUEST_QUEUE_READS": { "type": "integer", "example": 0 }, "REQUEST_QUEUE_WRITES": { "type": "integer", "example": 0 }, "DATA_TRANSFER_INTERNAL_GBYTES": { "type": "integer", "example": 0 }, "DATA_TRANSFER_EXTERNAL_GBYTES": { "type": "integer", "example": 0 }, "PROXY_RESIDENTIAL_TRANSFER_GBYTES": { "type": "integer", "example": 0 }, "PROXY_SERPS": { "type": "integer", "example": 0 } } }, "usageTotalUsd": { "type": "number", "example": 0.00005 }, "usageUsd": { "type": "object", "properties": { "ACTOR_COMPUTE_UNITS": { "type": "integer", "example": 0 }, "DATASET_READS": { "type": "integer", "example": 0 }, "DATASET_WRITES": { "type": "integer", "example": 0 }, "KEY_VALUE_STORE_READS": { "type": "integer", "example": 0 }, "KEY_VALUE_STORE_WRITES": { "type": "number", "example": 0.00005 }, "KEY_VALUE_STORE_LISTS": { "type": "integer", "example": 0 }, "REQUEST_QUEUE_READS": { "type": "integer", "example": 0 }, "REQUEST_QUEUE_WRITES": { "type": "integer", "example": 0 }, "DATA_TRANSFER_INTERNAL_GBYTES": { "type": "integer", "example": 0 }, "DATA_TRANSFER_EXTERNAL_GBYTES": { "type": "integer", "example": 0 }, "PROXY_RESIDENTIAL_TRANSFER_GBYTES": { "type": "integer", "example": 0 }, "PROXY_SERPS": { "type": "integer", "example": 0 } } } } } } } } } } ```