For developers building AI-visibility tools

MentionsAPI vs OpenRouter: raw inference or a finished visibility product

OpenRouter and MentionsAPI are different categories that happen to sit on the same shelf. OpenRouter is a unified LLM inference API: one endpoint that routes to hundreds of models, billed per token, on top of which you can build anything. MentionsAPI is a finished product for one job: checking brand visibility across AI surfaces, with the prompt fan-out, brand extraction, and rank/citation parsing already built in.

The honest question this page answers: could you build brand monitoring on OpenRouter yourself? Yes. It's a reasonable weekend-to-months project depending on how far you take it, and we lay out exactly what it involves below, including the part where raw model access hits a wall.

The shortest version: OpenRouter sells you the engine. MentionsAPI sells you the finished vehicle, but it only drives one route.

Get your API keyRead the docs

300 free credits · Plans from $5/mo · Calls debit credits

Credit-based·300 free credits · $5/mo → 1,000 credits · $54/yr → 12,000

What OpenRouter is

OpenRouter gives you one API key and one endpoint for hundreds of models across providers, with per-token pricing and easy model switching. For inference workloads (chat products, agents, summarization pipelines, model comparison for generative quality) it's an excellent piece of infrastructure, and if that's your workload you should use it.

It's deliberately unopinionated. OpenRouter returns what the model returns: prose. What you do with that prose is your code, which is exactly the flexibility inference customers want.

What MentionsAPI is

MentionsAPI is opinionated in the opposite direction. One call takes a query and a brand and returns structured JSON: mentioned or not, rank within the answer, cited URLs, per surface. The prompt handling, brand matching, and citation parsing are inside the API. You can't use it to build a chatbot, and that's the point.

It ships as a REST API plus a remote MCP server at api.mentionsapi.com/mcp, so agent workflows can call it as a tool without any HTTP glue.

Building brand monitoring on OpenRouter yourself

Here's the honest bill of materials. You'd write: a prompt set and fan-out logic per model, a brand matcher that survives casing and alias variants, rank computation within answers, citation extraction across each model's format, caching so repeat queries don't burn tokens, and scheduling plus storage for trend lines. None of it is exotic. All of it is maintenance, because model output formats and behaviors shift under you.

If brand monitoring is your core product and you want full control over every layer, building on raw inference is a legitimate choice. If it's a feature in a bigger product, or you'd rather spend the engineering elsewhere, one purpose-built endpoint replaces that whole list.

The wall: surfaces that aren't model APIs

There's a category of AI surface that no inference API can reach, because they aren't models you can route to. Google AI Overviews, Google AI Mode, and Bing Copilot are rendered products; what chatgpt.com shows a logged-in user differs from what the OpenAI API returns. You cannot check those surfaces through OpenRouter, no matter how much glue code you write, because there's no model endpoint behind them to call.

MentionsAPI's *_live modes check the rendered surfaces directly: AI Overviews (15 credits), AI Mode (35), Bing Copilot (15), and the live ChatGPT (35), Gemini (35), and Perplexity (85) UIs, with `mode: all_live` sweeping everything for 165 credits. If your monitoring needs to reflect what users actually see, this is the difference that decides the comparison.

Pricing models and which to pick

OpenRouter bills per token, which is the right model for inference: costs scale with usage and you choose the model tier per call. MentionsAPI bills fixed credits per check from a wallet: 300 free one-time on signup, $5/mo for 1,000 credits or $54/yr for 12,000, top-ups at $4 per 1,000 (monthly) or $3 per 1,000 (annual), credits never expire. A quick check is 130 credits fresh, 5 cached.

Pick OpenRouter for anything generative: chat products, agents, content pipelines, model experimentation. Pick MentionsAPI when the job is measurement: is the brand visible, where, with what citations, across API and live surfaces. Plenty of stacks run both, inference through OpenRouter and visibility checks through us, because the two never overlap in what they do.

FAQ

Frequently asked questions

Answer-first, dev-to-dev. Each one is also embedded as FAQPage schema for AI engines.

Which should I use: MentionsAPI or OpenRouter?
They do different jobs. OpenRouter is raw LLM inference: one endpoint to hundreds of models, per-token billing, build anything. MentionsAPI is a finished visibility product: one call returns mentioned/rank/citations per AI surface. If you're generating text, use OpenRouter. If you're measuring brand presence in AI answers, use MentionsAPI. Many stacks use both.
Can I build brand monitoring on OpenRouter myself?
Yes. You'd write prompt fan-out per model, brand matching with alias handling, rank computation, citation parsing per format, caching, scheduling, and storage, and then maintain all of it as model behaviors shift. If monitoring is your core product and you want full control, that's a legitimate build. If it's a feature, one purpose-built endpoint replaces the list.
Does OpenRouter track Google AI Overviews or Bing Copilot?
No, and it can't be made to. AI Overviews, Google AI Mode, and Bing Copilot are rendered products, not model APIs; there's no endpoint for OpenRouter to route a request to. The same goes for what the live chatgpt.com UI shows versus the OpenAI API. MentionsAPI checks those surfaces via *_live modes: AI Overviews 15 credits, AI Mode 35, Bing Copilot 15, all_live 165 for the full sweep.
Is MentionsAPI built on OpenRouter?
No. We maintain our own integrations with each provider for the API modes, and the live UI surfaces are checked directly since no inference router can reach them. OpenRouter and MentionsAPI are independent products; the overlap is that both give a developer one key instead of many, for very different workloads.
How does pricing compare?
OpenRouter is per-token: cost scales with usage and model choice, which fits inference. MentionsAPI is fixed credits per check from a wallet: 300 free one-time, $5/mo for 1,000 credits or $54/yr for 12,000, top-ups $4/$3 per 1,000, credits never expire. A quick check is 130 credits fresh and 5 cached, so a repeat monitoring workload prices out flat and predictable.
Can I use both OpenRouter and MentionsAPI?
Yes, and it's a sensible stack. Run your generative workloads (chat, agents, content) through OpenRouter and your measurement workloads (brand visibility, citation tracking) through MentionsAPI. There's no overlap in what the two do, so there's nothing to reconcile. Agents can hold both as tools; ours ships as a remote MCP server at api.mentionsapi.com/mcp.
What does one MentionsAPI check actually return?
Structured JSON per surface: whether the brand was mentioned, its rank within the answer, and the cited URLs, already extracted and normalized. No prose parsing on your side. A quick check covers ChatGPT, Claude, Gemini, and Perplexity in parallel for 130 credits fresh (5 cached); live modes return the same shape for rendered surfaces like AI Overviews.
When is OpenRouter the better choice?
Whenever the output you want is generated text rather than a measurement. Chat products, agent loops, summarization, drafting, model comparison for quality: OpenRouter gives you model breadth, streaming, and per-token economics that a fixed-price visibility API deliberately does not. Use us for the measuring, use OpenRouter for the making.
Code example

Visibility check without building the pipeline

Drop in your API key and you're live. Same response shape across every provider.

 main.py
import requests

res = requests.post(
    "https://api.mentionsapi.com/v1/ask",
    headers={"Authorization": "Bearer lvk_live_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"},
    json={
        "providers": ["openai", "anthropic", "gemini", "perplexity"],
        "prompt": "What are the best uptime monitoring tools?",
        "track_brands": ["UptimeRobot", "Pingdom", "Checkly"],
    },
)
data = res.json()
for result in data["results"]:
    for mention in result["mentions"]:
        print(result["provider"], mention["brand"], mention["position"])
Compare

OpenRouter vs MentionsAPI at a glance

 The other wayMentionsAPI
OpenRouterRaw model access; you buildFinished visibility endpoint
OpenRouterModel APIs onlyModel APIs + live UI surfaces
OpenRouterPer-token billingFixed credits per check
OpenRouterProse out; you parse for mentionsMentioned, rank, citations returned
Pricing

Start free. Subscribe for $5/mo. Calls debit credits.

Fixed credits per check, no token math. 300 free credits one-time on signup; $5/mo for 1,000 credits, $54/yr for 12,000; top-ups $4 per 1,000 monthly, $3 per 1,000 annual; credits never expire. Quick check 130 fresh / 5 cached; AI Overviews 15; all_live 165.

Get startedSee pricing

Stop wiring up four SDKs.

One API key, four answer engines, structured responses. 300 free credits on signup, plans from $5/mo.

Get your API keyRead the quickstart