Bragproof

← Reports

vantage-ai-visibility-mcp

Starts with no setup1.0.0npm

Installed, started with no arguments, no environment and no input, and listed its tools. Run 2026-11-16.

Needs to start: nothing
Returns a result when called with no setup: 0 of 2 tools tried
Contacts while installing and starting: vantagemcp.dev

11tools listed
1host contacted
5files written
1.7 sto start
81dependencies

What it contacted

Hosts it looked up or connected to while installing and starting with no input, watched from outside its sandbox. The npm registry is left out. Says nothing about what its tools contact when called.

Starting it

npx -y vantage-ai-visibility-mcp@1.0.0

Installing a package runs its code. Use a sandbox for anything you have not read.

Calling its tools

2 tools that take no input and look read-only were called once with nothing. 0 returned a result.

get_supported_optionsNo usable answer tools/call timed out after 15000 ms
get_usageNo usable answer tools/call timed out after 15000 ms

During the calls it contacted nothing it had not already contacted.

Only tools whose names read like looking something up, with no required input, are tried, five at most. Tools that need input, and anything that sounds like it changes or sends something, are not called.

What its tools tell an agent

In the tool descriptions, nothing that talks about the user, other tools or private files, or uses hidden characters.

4 tools with commands in capitals or very long text
  • Very long description in find_citation_leaders: 2678 characters or more
  • Very long description in analyze_citation_trend: 2658 characters or more
  • Very long description in analyze_citation_coverage: 3000 characters or more
  • Very long description in analyze_citation_gap: 2805 characters or more

Common and usually harmless: it is how many makers stress how a tool should be used.

Found by simple pattern rules in each tool's description (up to 3,000 characters), quoted as written. Parameter descriptions are not scanned. A clean result is not a safety review.

Tools

get_supported_options
List which AI engines, platforms and markets each Vantage tool
accepts, and the per-call limits, so you can pick valid arguments before
spending any quota. Use this to answer 'does Vantage cover Gemini in
Italy' or 'what can I pass as engine or platform'.

Costs 0 quota units - a fixed list, it never touches the data provider.

Returns: {"live_answer": {"tools" (analyze_citation_coverage,
analyze_citation_structure, analyze_citation_structure_batch,
analyze_citation_gap), "engines" (the values for `engine`),
"country" (any country name the provider accepts; for perplexity one of
"perplexity_countries" or a 2-letter ISO code), "language" (language
code), "max_samples", "max_keywords_per_call"}, "tracked_data":
{"tools" (find_citation_leaders, analyze_citation_trend,
find_cited_questions), "platforms" (the values for `platform`),
"chat_gpt_market" (the only market ChatGPT has tracked data for),
"other_markets" (where to get the rest), "max_trend_months",
"max_compare_domains" ({"find_citation_leaders", "analyze_citation_trend"})},
"default_market" ({"country", "language"})}. A market the provider does
not cover comes back as a refunded error, never a charge.
get_usage
Check how much of this billing period's quota is left, before
spending any of it. Use this to answer 'how many checks do I have left'
or to decide whether a batch call will fit before running it.

Costs 0 quota units - this never touches the paid data provider, it
only reads Vantage's own record of what has been used.

Returns: {"tier", "period" (YYYY-MM), "units_used", "units_limit",
"units_remaining"}. find_citation_leaders and find_cited_questions cost
10 units/call, analyze_citation_trend 10 per domain looked up;
analyze_citation_structure (and its batch form, per keyword),
analyze_citation_coverage (per keyword) and analyze_citation_gap cost 1,
times `samples` where a tool takes it. get_check_history,
check_page_readiness and get_supported_options cost 0.

stdio/local-dev mode (no HTTP access token) has no metering at all -
this returns tier "unmetered" with no real limit in that case.
find_citation_leaders keyword, platform, compare_domain, country, language, compare_domains
Find which domains dominate AI-answer citations for a topic/keyword,
and optionally check where one domain, or several competitors at once,
show up among them. Use this to answer 'who's winning AI search for this
topic' or 'is my competitor cited more than me for X'. Comparing several
domains costs the same single call.

Read-only: no side effects, safe to retry. Costs 10 quota units/call
(free tier is 30 units/month shared across every metered tool, so up to 3
calls to this tool alone if nothing else is used that period).

Returns: {"keyword", "platform", "top_domains" (list of {"domain",
"mentions"}, most-cited domains for this keyword/platform, order as
ranked by the provider), "top_domains_limit" (int, the provider's own
cap on this list - absence from it is NOT evidence a domain has zero
citations, only that it did not rank in the top `top_domains_limit`),
"compare_domain_rank" (int|null, only present when compare_domain was
passed: the domain's 1-based position in top_domains, or null if it
did not rank in the top `top_domains_limit`), "compare_domain_ranks"
(only present when compare_domains was passed: {domain: rank or null},
same rank rule as compare_domain_rank), "country", "language",
"source_mix" ({"community_pct" (share of these mentions that go to
community sites such as Reddit, YouTube, X, Quora), "community_domains",
"other_domains"}: a high community_pct means this topic is won by what
people say about a brand elsewhere, not by any one site's pages)}.

This tool's citation universe is the provider's tracked mention corpus
for the keyword, which is a different measurement from
analyze_citation_structure's single live answer - the two can
legitimately disagree on whether a given domain shows up.

Args:
    keyword: the topic/query to check, e.g. "best project management tool".
    platform: "chat_gpt" or "google" (Google's AI Overview). Defaults
        to chat_gpt. Perplexity and Gemini aren't available - the
        underlying data provider doesn't cover them for this check.
    compare_domain: optional bare domain to look up in the results
        (exact match against the registrable domain, e.g. "notion.so"
        will not match "mynotion.so.example.com").
    country: market to check, e.g. "Italy". Defaults to "United States".
        chat_gpt only has data for the United States; use platform
        "google" for any other country.
    language: language code, e.g. "it". Defaults to "en" (the only
        option for chat_gpt).
    compare_domains: optional list of up to 10 bare domains to rank side
        by side, e.g. ["notion.so", "asana.com", "monday.com"]. Same
        exact-match rule as compare_domain.
analyze_citation_trend domain, platform, months, country, language, compare_domains
Track how a domain's AI-citation count has moved month over month,
so you can see whether visibility is growing or fading instead of
only ever checking a single point in time. Use this to answer 'is our
AI visibility improving' or 'did that content push actually move the
needle'. Pass compare_domains to put competitors' trends next to it.

Read-only: no side effects, safe to retry. Costs 10 quota units per
domain (the main domain plus each one in compare_domains; free tier is 30
units/month shared across every metered tool, so up to 3 single-domain
calls to this tool alone if nothing else is used that period). A domain
the provider fails on is not charged.

Returns: {"domain", "platform", "months" (list of {"year", "month",
"mentions" (int, 0 for a month with no tracked citations. A zero
between two large months can be a gap in the provider's history rather
than a real drop, so read isolated zeros with care), "ai_search_volume"},
oldest to newest),
"trend": {"direction" ("up"/"down"/"flat"/"no_data"), "earliest_mentions",
"latest_mentions", "excluded_current_partial_month" (bool, only present
and true when the most recent calendar month was excluded from the trend
calculation because it is still in progress and its count is not yet
final - it is still returned inside `months`, just not compared)}}.

The most recent entry in `months` (or `trend.latest_mentions` when the
current month is not excluded) already IS the current count, so there is
no need for a separate call just to see it right now.

With compare_domains the result also carries "comparisons" (one
{"domain", "months", "trend"} per extra domain, same shape and month
window as above, in the order given, or {"domain", "error"} for one the
provider failed on - that one is refunded and the rest still return).

Args:
    domain: bare domain to check, e.g. "example.com" (no https://, no www).
    compare_domains: optional list of up to 5 more bare domains to track
        over the same months, e.g. ["asana.com", "monday.com"].
    platform: "chat_gpt" or "google" (Google's AI Overview). Defaults
        to chat_gpt. Perplexity and Gemini aren't available - the
        underlying data provider doesn't cover them for this check.
    months: how many recent months of history to return. Defaults to
        6, capped at 13 - DataForSEO's historical data only goes back
        to 2025-08-01.
    country: market to check, e.g. "Italy". Defaults to "United States".
        chat_gpt only has data for the United States; use platform
        "google" for any other country.
    language: language code, e.g. "it". Defaults to "en" (the only
        option for chat_gpt).
analyze_citation_structure keyword, country, language, engine, samples
Analyze the structural shape of the AI-generated answer actually
cited for a keyword: does it lead with a list, how long is the opening
passage, how many sources does it cite and from which domains. Use
this to understand what a winning AI-search answer looks like for a
topic, e.g. before writing content on it.

Read-only: no side effects, safe to retry. Costs 1 quota unit per sample
(1 by default; free tier is 30 units/month shared across every metered
tool, so up to 30 single-sample calls to this tool alone if nothing else
is used that period).

Returns: {"keyword", "engine", "model" (the answering model's version, as
the provider reports it), "checked_at" (when the answer was fetched, UTC),
"leads_with_list" (bool), "opening" (the answer's opening paragraph, as
text), "opening_word_count" (int), "opening_has_number" (bool),
"detail_preview" (up to 240 characters of what follows the opening,
cut at a word), "outline" (list of up to 12 section
heads, in order: the answer's headings, or its top-level list items when it
has fewer than two headings; heads only, never the text under them),
"has_table" (bool), "num_sources_cited" (int),
"source_domains" (list of up to 10 domain strings), "source_urls" (the
exact cited page URLs, up to 30, so you can see which page of a domain was
cited), "source_mix"
({"community_pct" (share of those sources that are community sites such
as Reddit, YouTube, X, Quora), "community_domains", "other_domains"}),
"country", "language"}. With samples above 1 the shape fields describe
the first answer, plus "samples_ok" (answers that came back) and
"source_frequency" (list of {"domain", "runs"}: how many of the answers
cited each domain, most often first). Answers change from run to run, so
a domain cited in every sample is a far stronger signal than one sample.

Args:
    keyword: the topic/query to analyze, e.g. "how to reduce churn".
    country: market to read the answer in, e.g. "Italy". Defaults to
        "United States". For perplexity a 2-letter code also works.
    language: language code, e.g. "it". Defaults to "en". Write the
        keyword in that language too.
    engine: "chat_gpt" (default), "gemini" or "perplexity". chat_gpt and
        gemini are the answers a person sees in those apps; perplexity is
        Perplexity's sonar API with web search.
    samples: how many independent answers to read, 1 to 5. Default 1.
6 more tools
analyze_citation_structure_batch keywords, country, language, engine
Analyze the structural shape of the winning AI answer across several
related keywords/topics in one call: does each lead with a list, how
long is the opening, how many sources it cites. It covers a topic
cluster in one call, for content planning across related pieces.

Read-only: no side effects, safe to retry. Costs 1 quota unit per
keyword in the batch (free tier is 30 units/month shared across all
the metered tools, so up to 30 keywords total that period if nothing else
is used). A per-keyword provider error doesn't fail the whole batch -
that keyword's entry just carries an "error" field instead.

Returns: {"results" (list, one {"keyword", ...same shape as
analyze_citation_structure, or "error"} per keyword, in the order given),
"summary": {"topics_analyzed", "topics_requested", "list_led_count",
"avg_sources_cited", "avg_community_pct" (average source_mix.community_pct
across the analyzed topics)}}.

Args:
    keywords: topics/queries to analyze, e.g. ["how to reduce churn",
        "churn rate benchmarks", "reduce customer churn saas"]. Max 10.
    country: market to read the answers in, e.g. "Italy". Defaults to
        "United States".
    language: language code, e.g. "it". Defaults to "en".
    engine: "chat_gpt" (default), "gemini" or "perplexity", as in
        analyze_citation_structure. One answer per topic.
analyze_citation_coverage domain, keywords, brand, country, language, engine, samples
Check which of several prompts/keywords actually cite a specific
domain, and which ones don't. It answers "out of everything we care about, where do we already
show up, and where are we invisible"; its not_cited list is the set of
keywords worth a closer look.

Read-only for the caller, safe to retry. Costs 1 quota unit per keyword
per sample (1 sample by default; free tier is 30 units/month shared
across every metered tool, so up to 30 keyword checks that period if
nothing else is used). A per-keyword provider error doesn't fail the
whole call - that keyword's entry just carries an "error" field instead.
On the hosted endpoint each keyword's result is remembered for 180 days
against your API key, so the next check of the same domain and keyword
reports what changed (see "previous" and "change"); get_check_history
reads that record back for free.

Returns: {"domain", "engine", "samples", "keywords_checked" (int,
excludes any that errored), "keywords_cited" (int), "coverage_pct"
(float, 0-100), "not_cited" (list of the keyword strings where domain
was not cited - the actionable list), "newly_cited" and "no_longer_cited"
(keywords whose status flipped since your last check of them), "results"
(one entry per keyword, in the order given: {"keyword", "cited" (bool:
cited in at least half of the samples), "cited_runs" (how many sampled
answers cited it), "samples_ok" (how many answers came back), "rank"
(int|null, best 1-based position among the answers' sources, null when
never cited), "cited_pages" (list of your own page URLs the answers cited,
empty when none - saved with the check, so get_check_history can follow
one page over time), "num_sources_cited", "source_domains" (who IS cited, for a
keyword you are not in), "source_mix" (how much of that is community
sites such as Reddit, YouTube, X - where to get discussed to close the
gap), "source_frequency" (only with samples above 1: {"domain", "runs"}
per domain), "leads_with_list", "opening_word_count", "mentioned" (bool -
the answer's text names the domain or brand in at least half of the
samples, whether or not it links to it), "model", "checked_at",
"previous" ({"checked_at", "cited_runs", "samples", "best_rank"} from
your last check of this domain and keyword on the same engine and
market with the same number of samples, or null), "change" ("first_check", "up", "down" or "same",
comparing citation rates)}, or {"keyword", "error"} for one that
failed), "keywords_mentioned" (int), "mentioned_not_cited" (keywords
where the answer names you but does not cite you - the model already
knows you, it just isn't linking you), "mention_terms" (exactly what was
looked for in the answer text)}. "Cited" and "mentioned" are separate
claims and are never merged. Answers change from run to run: with
samples=1 a single answer decides "cited", so one sample is weak
evidence either way.

Args:
    domain: bare domain to check, e.g. "example.com" (no https://, no www).
    keywords: prompts/topics to check it agains
analyze_citation_gap keyword, your_url, country, language, engine, samples
Compare your own page's structure against the AI-generated answer
actually cited for this keyword, and return a fix brief: the differences
between the two, each with the change worth testing, not just a
description of the winner. Use this to answer 'how does my page differ
from what AI cites for this, and what could I try'. The brief lists
things to test, not proven causes of citation. It never contains the
cited answer's text.

Read-only: no side effects, safe to retry. Costs 1 quota unit per sample
(1 by default; free tier is 30 units/month shared across every metered
tool, so up to 30 single-sample calls to this tool alone if nothing else
is used that period). A sample that fails is not charged.

Returns: {"keyword", "your_url", "already_cited" (bool: your page's site
is among the answer's sources, in at least half of them with samples
above 1; when true, fix_brief is one line saying so instead of changes),
"basis" (one sentence: how many answers, which engine and market, and
that the brief lists things to test), "samples_ok" and
"cited_in_answers" (only with samples above 1), "winning" (structure of the
AI-cited answer, same shape as analyze_citation_structure), "yours"
(same structure computed for your_url, including its own "outline" and
"has_table", with "num_links_out"/"linked_domains" standing in for
source count), "gaps" (list of plain-English differences worth acting
on), "possibly_missing" (heads from the winning outline whose key words
mostly do not appear on your page; word matching, so check each before
adding it), "fix_brief" (list, most important first, each line what was
observed then what is worth testing: opening, number, list, sections,
missing points, table, then a reminder to write in your own words - or a
"no structural change indicated" line when every check already matches -
and always last, one off-site option drawn from the winning answer's
source_mix: which community sites (Reddit, YouTube, X...) it cites, or
which other sites to get mentioned on). With samples above 1, "winning"
is the first answer, and a brief line or missing point needs at least half
the answers behind it}, or {"error"} if either side couldn't be
fetched/parsed.

Args:
    keyword: the topic/query to check, e.g. "best project management tool".
    your_url: full URL of your own page to compare, e.g.
        "https://example.com/best-project-management-tools".
    country: market to read the cited answer in, e.g. "Italy". Defaults
        to "United States".
    language: language code, e.g. "it". Defaults to "en".
    engine: "chat_gpt" (default), "gemini" or "perplexity": whose answer
        to compare your page against.
    samples: how many independent answers to read, 1 to 5. Default 1.
        Answers change from run to run; 3 gives a steadier brief.
find_cited_questions domain, platform, limit, country, language
Find the questions people ask AI answer engines where a domain is
already cited as a source, most-asked first. Starts from the domain, so
nobody has to guess keywords first. Use this to answer 'what does
ChatGPT already cite us for' or to pick the keywords to feed
analyze_citation_coverage and analyze_citation_gap.

Read-only: no side effects, safe to retry. Costs 10 quota units/call
(free tier is 30 units/month shared across every metered tool, so up to 3
calls to this tool alone if nothing else is used that period).

Returns: {"domain", "platform", "country", "language", "total_questions"
(int, every tracked question citing the domain, which can exceed the
list), "questions" (up to `limit`, most-asked first: {"question",
"ai_search_volume" (monthly asks as the provider estimates them),
"your_position" (1-based position of the domain among that answer's
sources), "source_domains" (who else that answer cites), "last_seen"
(when the provider last recorded this answer, UTC)})}. An empty list means
the provider's tracked answers do not cite the domain, not that no
answer anywhere does.

This reads the provider's tracked answer corpus, the same measurement as
find_citation_leaders, not a live answer: re-check a question with
analyze_citation_coverage to see today's answer.

Args:
    domain: bare domain, e.g. "example.com" (no https://, no www).
        Subdomains are included.
    platform: "chat_gpt" (default) or "google" (Google's AI Overview).
    limit: how many questions to return, 1 to 20. Default 20.
    country: market, e.g. "Italy". Defaults to "United States". chat_gpt
        only has United States data; use platform "google" elsewhere.
    language: language code, e.g. "it". Defaults to "en", the only
        option for chat_gpt.
get_check_history domain, keyword, limit, page
Read back your own earlier analyze_citation_coverage results for a domain,
newest first, to show progress over time or to confirm whether a change
(a rewrite, a new mention somewhere) moved anything. Use this for 'has
our citation status changed since last week' without spending units.
Pass `page` to follow ONE page's citations over time instead of the whole
domain's.

Costs 0 quota units: it only reads Vantage's own record of your checks,
never the data provider. Results are kept 180 days per API key and are
only visible to that key.

Returns: {"domain", "keyword" (or null for every keyword), "page" (the
URL asked about, or null), "checks" (newest first: {"keyword", "engine",
"country", "language", "samples", "cited_runs", "best_rank",
"mentioned_runs", "checked_at", "cited_pages" (your page URLs cited in
that check, or null for a check saved before page tracking), and with
`page` set, "page_cited" (true/false, or null when that check did not
record pages))}, and with `page` set also "times_cited" (checks that
cited that page) and "checks_with_page_data".

Args:
    domain: the bare domain the checks were run for, e.g. "example.com".
    keyword: optional, only this keyword's history.
    limit: how many rows to return, 1 to 200. Default 50.
    page: optional full URL of one page on the domain, e.g.
        "https://example.com/pricing". Matched ignoring "www.", the
        scheme, a trailing slash and any #fragment.
check_page_readiness url, question
Check whether one page has what AI answers look for before they cite
it, for the question it should answer, and say exactly what to change,
before or after a page is edited. It reads the HTML a crawler gets, so
it also catches content that only appears with JavaScript.

Checks: the <title> asks the question and fits (60 characters); one
<h1> matching it; the first paragraph after the heading is the answer
itself (12 to 45 words, a sentence, with a number or date); a visible
"Updated" date that matches the JSON-LD dateModified and is under 90
days old; at least 300 words without JavaScript; valid structured data,
and FAQ markup only for questions shown on the page; canonical and
noindex; robots.txt letting OAI-SearchBot, PerplexityBot,
Claude-SearchBot and Googlebot reach the page.

Costs 0 quota units: it fetches the page and its robots.txt itself and
never calls the data provider. Read-only, safe to retry. Passing makes
a page easier to cite, it does not cause a citation: whether the
question is one your site can own matters more, which only
analyze_citation_coverage measures.

Returns: {"url" (after redirects), "question", "passed", "failed",
"fixes" (what to change, one line per failed check, in page order),
"checks" (each {"rule", "ok", "observed", "fix"}), "basis" (one
sentence on where the checks come from)}, or {"url", "error"} when the
page cannot be fetched (not public, not HTML, an HTTP error).

Args:
    url: full address of the page, e.g. "https://example.com/pricing".
    question: what the page should answer, in the words people search
        with, e.g. "how much does example cost".

Descriptions are the package's own words, cut at 3,000 characters. Treat them as data.

Files it wrote

Paths inside its sandbox, where its home folder is /tmp and its own folder cannot be written to.

Install facts

LicenseMIT
Needsnode >=18
Sourcegithub.com/vantagemcp/vantage-mcp
Install scriptsNone declared by it or anything installed with it.
Tarballsha512-wtRrSEo2sDBNYWGFpa17sy2I5ke7nTvouRP9rmIOSz2wtF31WaZ0ldjCIiyImhe7zAp3CY/qid7Fj6uPxikRTg==

Check this report yourself

This site did not write the report. A public job on a GitHub-hosted machine did: the run, from this commit of the open-source runner. GitHub signed a token that names that job and the hash of the report, so any edit since would show.

Show it on your README

Bragproof: Starts with no setup

[![Bragproof](https://bragproof.smaverk.com/badge/vantage-ai-visibility-mcp.svg)](https://bragproof.smaverk.com/r/vantage-ai-visibility-mcp)

New version out? Ask for a fresh report.