Optifeed Radar

Optifeed Radar

Open-source AI visibility checker. Now on npm - run it with npx optifeed-radar.

Is your brand recommended when buyers ask AI? Optifeed Radar checks whetherChatGPT, Perplexity, Gemini and Claude actually recommend you, and tells youwhere you stand against competitors. It runs locally, uses your own API keys,and has no Optifeed-hosted backend.

It is built for two kinds of AI agents at once: it measures how AI agentssee and recommend you, and it can be run by your own AI agents (CLI, JSON,and an MCP server). People also call this AI visibility, generative engineoptimization (GEO), answer engine optimization (AEO), or AI-SEO.

60-second setup

No install needed - npx fetches and runs it. The zero-key audit runs endto end with no API keys and no AI calls:

npx optifeed-radar audit yourbrand.com

It checks AI-crawler access (robots.txt), llms.txt, schema.org structureddata, meta basics, and your sitemap, then prints a 0-100 AI-readiness score.

The check pipeline runs once you set at least one engine API key. Put it in a.env file in the directory you run from, or export it:

echo "OPENAI_API_KEY=sk-..." > .env      # any one engine key gets you started
npx optifeed-radar check yourbrand.com

The CLI loads .env from the directory you run it in, so there is no shellsetup step. Exporting the keys works too (export OPENAI_API_KEY=...), and anexported key always wins over the same key in .env. config shows whichkeys were found and which file they came from, never the values.

It discovers your brand, generates a buyer-prompt pack, asks the engines, andscores recommendation, position, and share of voice into one AI VisibilityScore. The score reads only the unbranded buyer questions (did the AI surfaceyou unprompted); questions that name your brand are reported separately asreputation. All four engines are verified live against their production APIs(2026-07-20).

Working from a clone instead? Run npx tsx src/cli/index.ts <command> so flagsreach the CLI unchanged, or use the npm run dev script with -- before thearguments (npm run dev -- check yourbrand.com --report out.html).

See it in action

Run a full visibility check from the terminal, from brand discovery and buyerprompt generation through live engine queries and scoring.

Watch the 15-second CLI demo

What it does

Optifeed Radar asks real AI engines real buyer questions and measures whetheryour brand gets recommended - not whether you rank in a search index, butwhether the answer an AI gives a buyer names you. Grounded engines (which citeweb sources) are reported separately from parametric ones (which answer frommodel weights alone), because they behave differently. An engine counts asgrounded only for the answers where it actually searched: asking for groundedmode is a request a model can decline, so the report says when an enginesearched on only some of its answers. METHODOLOGY.md has theformula.

The questions match what you sell. If you make your own products, buyers areasked what to buy and you are measured against rival makers. If you are a shopselling other companies' products, buyers are asked where to buy and you aremeasured against rival shops - product questions get answered withmanufacturers, so scoring a shop on them reports a zero that says nothing aboutthe shop. The tool works this out from your site and stores it asbusinessType in profile.json; edit it if it guessed wrong.

One level down, shopping does the same thing for individual products youname (beta). Each product gets its own 0-100 visibility score, and the reportis ordered by what the engines did: any product they answered about but neverrecommended leads, since that is the finding worth reading, then the rest byvisibility, and last anything the run could not measure at all. The order youlist your products in carries no ranking meaning; it only breaks ties betweenidentical scores. Each product is checked twice over - categorybuying questions that never name it, and questions that do - and when aproduct is absent the report leads with the rival products the engines namedinstead, which is the more useful half of a zero. Because every product isasked its own questions, the scores say how decisively each one wins its ownshelf, not that one product beats another. You name the products; nothing isimported or crawled.

Use it from your AI agents (MCP)

The optifeed-mcp server exposes the same capability to AI agents. It runsover stdio, and npx fetches it on demand - no clone or build needed.

Claude Desktop (claude_desktop_config.json). The fastest way to open it isSettings -> Developer -> Edit Config, which creates the file if it does notexist yet. On disk it lives at:

• macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
• Windows: %APPDATA%\Claude\claude_desktop_config.json

{
  "mcpServers": {
    "optifeed-radar": {
      "command": "npx",
      "args": ["-y", "--package=optifeed-radar", "optifeed-mcp"],
      "env": {
        "OPENAI_API_KEY": "sk-..."
      }
    }
  }
}

Claude Desktop reads that file at startup, so quit and reopen it after editing.

Claude Code (.mcp.json in your project):

{
  "mcpServers": {
    "optifeed-radar": {
      "command": "npx",
      "args": ["-y", "--package=optifeed-radar", "optifeed-mcp"]
    }
  }
}

Cursor (.cursor/mcp.json) and Windsurf (mcp_config.json) use the sameshape:

{
  "mcpServers": {
    "optifeed-radar": {
      "command": "npx",
      "args": ["-y", "--package=optifeed-radar", "optifeed-mcp"]
    }
  }
}

Working from a clone instead? Build first (npm install && npm run build),then run the server with node pointed at the built entrypoint - replace/path/to/optifeed-radar with your clone path:

{
  "mcpServers": {
    "optifeed-radar": {
      "command": "node",
      "args": ["/path/to/optifeed-radar/dist/mcp/index.js"]
    }
  }
}

Example prompts

Once it is connected, ask your AI agent in plain language. These map onto thefive tools and the arguments they accept:

• "Run a free AI-readiness audit on yourbrand.com." -> audit_store, no keys,no cost.
• "What buyer questions should yourbrand.com be visible for?" ->generate_buyer_queries, so you can review the pack before paying for a run.
• "Check yourbrand.com's AI visibility, quick mode, cap it at 20 cents." ->check_visibility with quick and max_cost.
• "Check yourbrand.com on OpenAI and Perplexity only." -> check_visibilitywith engines.
• "Check whether AI recommends my products: Aria 2, Presto X, Brew Mini, inthat order, for yourbrand.com." -> shopping_check. Input order is not aranking; it only breaks ties between products with identical scores.
• "Check the Aria 2, a quiet home espresso machine, and the Presto X, a fastdual-boiler, on yourbrand.com. Cap it at one dollar." -> shopping_checkwith a descriptor per product and max_cost. Saying what each product IS iswhat rescues an opaque model name: without it the questions are guessed fromthe store category.
• "What changed since the last visibility run on yourbrand.com?" ->get_snapshot_diff, free, and it needs two saved runs before it can compare.

Start with the audit prompt: it needs no keys, so it confirms the server iswired up before anything spends API credit. check_visibility runsnon-interactively (no confirmation prompt over MCP), so the max_cost cap iswhat bounds a run your AI agent starts - it defaults to $0.50.shopping_check is bigger, so its default cap scales with the list, at $0.20per product you name.

Tools and cost

Cost transparency: audit queries no AI engines and costs nothing. checkspends your own API credit. Measured on real runs (2026-07-20, --quick =8 buyer prompts):

Your cost varies with engine, prompt-pack size, and provider pricing. Groundedruns cost roughly 3x parametric ones, because web search is billed on top oftokens: Google charges per search query, and one answer can trigger several.The grounded range spans three real runs: two finished clean at about $0.85,and one that was reined in by its own cap spent $1.09, so treat the top of therange as the planning number.

shopping was measured on 2026-07-23: two products across all four engines in--grounded mode, 32 answers, $0.70 for the run - about $0.35 per product.That is the expensive corner (grounded runs cost roughly 3x parametric ones),so a parametric four-engine run lands well under it. Each product costs about4 prompts on every engine with a key, and products in the same category sharetheir category questions, which are asked once and scored for each product.The MCP tool's default cap is $0.20 per product, which a grounded run willreach, so raise max_cost when you want grounded across four engines. Use--max-cost and start with two or three products.

How long it takes, measured the same way (2026-07-22):

The install figure was measured from the packed tarball with an empty npmcache, so a cold npx optifeed-radar audit yourbrand.com from the registryshould finish in about ten seconds. A check takes as long as theengines take to answer: it queriesseveral of them across a whole prompt pack, and that wait is provider latencywe do not control. check reports live progress while it runs, so you can seewhich phase it is in rather than watching a blank terminal.

Every run reports what it actually spent, split into setup (brand discoveryand prompt generation) and engine calls, so you can reconcile it against yourprovider bill. Declining at the confirmation prompt still reports the setupcost, because discovery runs before that prompt.

--max-cost 0.20 caps spend. The cap is checked before every call and hittingit returns a partial result flagged as capped, never an error. It is a strongbound rather than an absolute ceiling: an engine's cost is not known until itscall returns, so a run can exceed the cap by at most the cost of oneunmeasured call per engine. Any overshoot is always reported, never hidden.

Useful check flags: --json (raw envelope), --report report.html(self-contained report), --max-cost 0.50, --quick (smaller prompt pack),--grounded (web-search mode where engines support it), --fail-under 50(exit non-zero below a threshold, for CI), --yes (skip the cost prompt so anAI agent can run it unattended).

Example

npx optifeed-radar audit example.com      # free readiness score
npx optifeed-radar check example.com --quick --yes
npx optifeed-radar shopping example.com --products "Aria 2, Presto X" --yes
npx optifeed-radar diff example.com        # what changed since last run
npx optifeed-radar sources example.com     # who the AI cited
npx optifeed-radar config                  # which keys are set

config reports only whether each key is present, never the key value.

For shopping, list up to 10 products per run in any order; only the first 10are checked, and the report is ordered by what the engines did, not by whatyou typed. A filegives each product a descriptor, which is what rescues an opaque productname - "Aria 2" tells an engine nothing, "quiet home espresso machine" tellsit everything:

products:
  - name: Aria 2
    aliases: [Aria II]
    descriptor: quiet home espresso machine
  - name: Presto X
    descriptor: fast dual-boiler espresso machine

npx optifeed-radar shopping example.com --products-file products.yml --yes

FAQ

What is AI visibility? Whether AI engines recommend your brand when a buyerasks them a question, rather than whether you rank in a traditional searchindex. It is also called generative engine optimization (GEO) or answer engineoptimization (AEO).

Is there an MCP server? Yes. The optifeed-mcp server exposescheck_visibility, audit_store, generate_buyer_queries, shopping_checkand get_snapshot_diff to your AI agents over stdio.

What does it cost? The audit command is free and needs no keys. Thecheck pipeline spends your own engine API credit: measured at about $0.09 fora quick single-engine run, $0.41 to $0.46 across all four, and $0.85 to $1.09with --grounded. Every run reports what it spent, and --max-cost caps it. Youbring your own keys; there is no Optifeed-hosted billing.

Where is my data stored? Optifeed Radar runs locally, saves snapshots onyour machine, and has no Optifeed-hosted backend. Each key is sent only to itscorresponding AI provider as required to make API calls and is never logged;prompts and responses are handled under that provider's data policies.

Which engines does it support? OpenAI (ChatGPT), Anthropic (Claude), Google(Gemini), and Perplexity. Set any one key to start; set more for broadercoverage.

How is the score computed? From sampling real engine answers to unbrandedbuyer questions, scoring recommendation, position, and share of voice. Scoresare estimates and vary between runs. See METHODOLOGY.md forthe full method.

For directory maintainers

One-liners for awesome-mcp-servers, ClawHub, and Smithery listings:

• Optifeed Radar - Ask real AI engines real buyer questions and scorewhether a brand gets recommended. CLI plus MCP server, runs locally, BYO keys.
• Optifeed Radar (MCP) - check_visibility, audit_store,generate_buyer_queries, shopping_check, and get_snapshot_diff formeasuring brand and product AI visibility (GEO / AEO) from your AI agents.

Search intents this serves: AI visibility checker, does AI recommend my brand,generative engine optimization (GEO) tool, answer engine optimization (AEO),ChatGPT brand visibility, AI-SEO, MCP server for brand visibility.

What this does NOT do

• It is a point-in-time check, not continuous monitoring.
• Scores are estimates from sampling and vary between runs - they are not aguaranteed ranking.
• It does not find your products for you. shopping checks the products youname, up to 10 per run; there is no catalog or feed import.
• check and shopping spend your own API credit; only audit is free.
• It is not a traditional SEO rank tracker.

Catalog discovery (pulling your products from a store or a feed) and feedlinting against the Agentic Commerce Protocol (ACP) and the Universal CommerceProtocol (UCP) will arrive in later releases - join the waitlist atoptifeed.com.

Status

Under active development, and the repo is public so you can follow along. Ifthis is useful to you, a star genuinely helps. Scores are estimates and say so.Your API keys are used only to call their corresponding providers and are neverlogged or stored by Optifeed Radar.

License

MIT

More at optifeed.com: https://www.optifeed.com/