AI visibility

A visibility project tracks one brand across the AI models. Create one under AI Visibility → New project, enter the brand name and website, and add the competitors you want to benchmark against. CrunchJunkie uses the brand and competitor names to detect mentions in AI responses, so spell them exactly as they appear in the market — including common variations if the brand is known by more than one name. Each project is independent, which makes it easy to run visibility for several clients side by side. Once the project exists, you add prompts and choose which models to scan, then CrunchJunkie takes over the daily monitoring.

Prompts are the questions CrunchJunkie asks the AI models on your behalf. Add them under the project's Prompts tab and tag each one by intent: Discovery prompts are unbranded category questions ("best marketing reporting tools for agencies"), Brand prompts name your client directly ("is Lumière any good?"), and Competitor prompts are comparisons or alternatives ("Lumière vs Velora"). A good starting set mixes all three categories — perhaps fifteen to thirty prompts that mirror how real buyers search. CrunchJunkie runs every prompt against every enabled model on each scan and records whether your brand was mentioned, where it ranked in the answer, how it was described, and which sources the model cited.

If you already have a list of prompts — in a spreadsheet, exported from another tool, or handed over by a client — import the whole list at once instead of typing each one. On the Prompts tab, click Import, then upload a CSV, TSV or Excel (.xlsx) file. CrunchJunkie reads one prompt per row and shows a preview of exactly what it will create before anything is saved. Download the template from the import dialog to see the columns. Only prompt is required; the rest are optional. The tags column holds one or more labels separated by a semicolon (for example "reporting; agencies"), or you can spread tags across several tag columns if that is how your sheet is built. category is one of discovery, brand, competitor or shopping — anything else falls back to discovery. market and language set a prompt's market override (a country name or code, and a language), so a single import can span several markets at once; leave them blank to inherit the project default. Set active to "no" to import a prompt switched off. Intent is applied automatically. You do not need an intent column: CrunchJunkie predicts each prompt's intent — Commercial, Informational or Navigational — from its wording, exactly as it does when you add a prompt by hand. If you would rather set it yourself, add an intent column and your value wins. Either way, every intent stays editable on the prompt afterwards. The preview tells you how many prompts are ready, how many were skipped (blank or over 2000 characters), how many rows were duplicates, and how many already exist in the project. CrunchJunkie never imports a prompt you are already tracking, so re-importing an updated list adds only what is new. Confirm, and the prompts appear in the table, ready to scan.

Every project has a market and a language, set under the project's Settings. They decide what each AI model is asked — not how many models run — and getting them right matters more than most settings in the product. They work differently depending on the engine, and the difference is the whole point. The seven chat models (ChatGPT, Gemini, Perplexity, Claude, Grok, DeepSeek, Meta AI) are told to answer as if for someone in that market, replying in that language. Google AI Overviews, Google AI Mode and Microsoft Copilot are searched from the selected country instead, because they are search surfaces rather than chat models. That second group is why prompt language matters. For AI Overviews and AI Mode, your prompt text is the search query. "beste Marketing-Agentur München" and "best marketing agency Munich" are two different searches — different results, different sources, different AI answers. No market setting changes that; only the prompt text does. So write prompts in the language your client's buyers actually search in. For a German client, German. The test is not what language your agency works in — it is what a real buyer types into ChatGPT or Google. A German SME looking for a supplier types German. One exception worth checking before you localise everything: in some categories and markets, buyers genuinely search in English because the English-language material dominates the field. B2B software in the Nordics and the Netherlands often behaves this way. If that is true of your client's category, English prompts are the correct measurement and you should keep them. The project's market and language are the default, but you can override the market on individual prompts — which is how one project tracks a brand across several markets at once. The next section covers it.

A brand that sells into more than one language market used to force an awkward choice: one project that pooled every market into a single, meaningless average, or a separate project — or worse, a separate client — per market, which split the brand and billed it twice. Neither is necessary. Market is set per prompt, so one project tracks a brand across as many markets as it sells into. On the Prompts tab, every prompt has a Market dropdown. Leave it on Inherit (project) to use the project's default, or pick a country to scan and pool that prompt in its own market. Write each prompt in the language that market's buyers actually search in — a German prompt set to Germany, an English one to the UK or US — for exactly the reasons in the section above. The market you pick is recorded on every run at scan time, so editing a prompt later never retroactively relabels the history you have already collected. Because each market is pooled on its own population, the numbers stay honest — and once a project spans more than one market, the Overview grows two things to read them with. A Filter by market switch at the top scopes the whole page — visibility, share of voice, sources, everything — to one market at a time, or All markets for the blended view. And a Markets table lists every market side by side: visibility, share of voice, sentiment, average position and run count, each pooled only on that market's own scans. Share of voice is always measured within a market and never blended across them, so a strong position in Germany never flatters a weak one in the UK. That side-by-side view is the part most visibility tools don't offer — it's where you see that you lead in one market and trail in another, which is usually the whole reason for tracking more than one. Multi-market tracking is included, not a paid add-on. It is metered the same way as everything else in AI visibility — by checks (prompts × engines × passes). Giving a prompt a specific market adds no surcharge; a prompt scanned in Germany costs exactly what any prompt costs. If you genuinely want the same question measured in two markets, that is two prompts — and so two prompts' worth of checks, the honest cost of measuring twice. Still, don't split one brand across two clients or two projects to separate markets. It bills the same brand twice, splits the reporting, and describes one company as two. Set the market on the prompt instead.

Coming up with the right prompts is the hardest part of setup, so Crunch can do the first pass for you. On the Prompts tab, click "Suggest prompts" and CrunchJunkie reads the project's brand, website, product type, the attributes you want to be known for, your competitors (and their domains) and the coverage you already have, then proposes realistic buyer questions across the intent mix — unbranded category queries, brand questions and competitor comparisons — that fill the gaps rather than duplicate what you track. The suggestions get sharper when the project has a Brand profile — a short description of what the business is, its market segment, positioning, audience and products. In the project's Settings, click "Auto-fill from site" to have Crunch read the brand's website and draft it (or write it by hand); it's fed straight into the suggestion prompt so ideas fit the actual business, not just the brand name. Everything is editable and never invented — a field the site doesn't support is left blank. Once the project has been scanned, discovery also leans on your own scan data: it weights suggestions toward the topics where competitors currently get recommended and you don't (the same measured gap as the Opportunity score), so the ideas target real weaknesses rather than generic category questions. Suggestions grounded that way carry a small Gap badge. Suggestions land in a review queue that survives reloads: each carries a short why — the competitor, use case, attribute or observed gap it targets — so you can see what it's grounded in. Add the ones that fit, dismiss the rest (a dismissed suggestion is remembered and never proposed again), and edit any after adding like a prompt you wrote yourself. A deliberate honesty note sits above them: these are grounded candidate questions, not measured demand. CrunchJunkie never shows a fabricated "AI prompt volume" — no tool can measure how often a topic is asked across ChatGPT, Perplexity or Gemini (the providers don't publish it), so a precise "searches/mo" figure is always a guess. You prioritise from what we can measure — the Opportunity score below — not from invented numbers. If you already have keywords in mind — product categories, use cases, search terms — use "From keywords" instead: paste them in (one per line or comma-separated) and Crunch turns each into realistic buyer questions across the intent mix, rather than restating the keyword verbatim. It's the quickest way to seed a tracking set around topics you care about, and the results are the same editable suggestions you add with a click.

Once a project has scan data, the Prompts table shows an Opportunity column, and clicking it sorts your prompts by where the biggest wins are. This is the honest, measured answer to "where should I spend effort?" — and it is deliberately not a demand or volume estimate. The score answers one question we can actually measure from your own scans: on this prompt, do competitors get recommended while you don't? A prompt reads High when rivals are named across many runs and you're absent on most — the classic gap to close. It's computed as competitor presence × (1 − your visibility), both pooled over the same runs, so a prompt where you already lead, or one nobody wins yet, correctly reads Low rather than as an opportunity. Each score carries its basis on hover ("You 0% · competitors 60% · 24 runs"), and — where the gap sits on specific engines — names them ("missing on Perplexity, Claude"), so you know exactly where to act. A small confidence dot from the sample size follows the same honesty rule as everywhere else: a prompt with only a handful of runs shows "Collecting" instead of a confident tier pulled from noise. Why no "prompt volume" next to it? Because there is no ground truth for how often a question is asked inside ChatGPT or Perplexity — the providers publish only aggregate totals, and the tools that print a precise "1,200 searches/mo" are extrapolating a consented browser panel that sees a fraction of usage (their own docs concede the figure "could be half or double — good for ranking, never a literal count"). Rather than resell a guess as a fact, CrunchJunkie prioritises from measured competitive gaps. Optionally (a beta, off by default) it can also show a clearly-labelled Google Keyword Planner search-volume figure next to each prompt — a proxy for traditional-search intent, never relabelled as AI demand. It's shown as a range ("1K–10K") rather than a false-precise number, and the exact keyword it looked up is shown for transparency, because a full AI-style question and a Google keyword are rarely identical. The opportunity ranking itself always stands on what we actually observed.

CrunchJunkie can track ten AI surfaces: ChatGPT, Gemini, Perplexity, Claude, Google AI Overviews, Google AI Mode, Microsoft Copilot, Grok, DeepSeek, and Meta AI. Enable the ones that matter for your client's audience under the project's Models settings — you don't have to run all ten. Each enabled model is scanned automatically every day. Each surface maps to a specific, current model version: ChatGPT is tracked on GPT-5.6 with web search, Gemini and Claude with web search, Perplexity on Sonar Pro, Grok with web search, Meta AI on Muse Spark, and Google AI Overviews and AI Mode through a search-results provider. Nine of the ten are web-search-grounded; DeepSeek is the exception, since its API has no built-in web search. The exact model each surface calls is shown on the Models settings page and evolves as providers ship new versions. Some models require specific setup. Google AI Overviews, for example, is tracked through a search-results provider rather than a chat API. The Models settings page tells you exactly what each one needs and shows the current status of every connection at a glance.

Every scan's cost comes down to three dials: how many prompts run, how many engines each prompt hits, and how many passes (runs) per prompt. Project Settings gives you one-click scan modes so you don't have to tune them by hand. Lite runs two efficient engines at a single pass — a cheap regular pulse. Balanced (the recommended default, and what every new brand starts on) runs the four engines that matter most at two passes. Thorough runs all ten engines at three passes for the highest confidence. Custom is whatever you set yourself — pick any engines and passes, and the mode label switches to Custom automatically. Settings shows a live estimate as you change the dials — "each scan runs ≈ N checks" — worked out as prompts × passes × engines, with premium engines (ChatGPT, Claude, Perplexity, Grok) weighted 3× because they cost about three times as much to run. That estimate is the same whether you're on Managed AI (where it counts against your monthly allowance) or your own keys (where the provider bills you directly), so you always know the cost of a configuration before you save it. More passes and more engines mean more accurate, more stable numbers; fewer of each keep cost down. Start on Balanced, then raise or lower it once you see how the brand's numbers move. Frequency is the fourth dial, and the biggest one. Daily scanning is available on every paid plan — we do not gate it, because on your own keys it costs us nothing and on Managed AI you are paying per check either way. But it is roughly seven times the monthly volume of weekly, so Settings shows the projected monthly total beside your chosen frequency, not just the per-scan figure. Weekly is the default, and for most brands it is the right one. AI answers do not move meaningfully from one day to the next, and a weekly scan with more passes is better evidence than a daily scan with fewer — you are sampling the same question more times, which is what actually reduces noise. Daily earns its cost when you are watching a specific change land: a site migration, a launch, a pricing page going live. Turn it up for those weeks, then turn it back down. If weekly is too sparse but daily is more than you need, set a custom rhythm — every N days — and Settings shows the projected monthly checks for whatever cadence you pick.

A gap prompt is one your buyers ask where AI engines mentioned you in zero measured runs. The Brief button on those rows generates an evidence-grounded content brief: CrunchJunkie assembles the actual AI answers for that exact prompt, the competitor pages those answers cited, and each winner's extracted GEO signals (direct quotations, statistics with named sources, authoritative outbound links — the signals peer-reviewed research shows raise citation rates). The brief is hard-constrained to that evidence: it never invents sources or figures, and when the evidence is thin it says "not enough signal" instead of guessing. Reopening a brief shows the saved version instantly — free — with a Regenerate button when you want it rebuilt from fresh evidence (that is a new AI call, metered like any other). Each brief stores its 0% baseline. Once you've published the page it describes, click Measure impact — CrunchJunkie re-scans that one prompt and compares only fresh runs against the baseline, so the lift you see is current evidence, not an average diluted by history. Batch briefing runs the same loop across every gap prompt at once. There's a full walkthrough — with a two-minute video — in the Resources hub: "Turn an AI-visibility gap into a cited page".

Each check in a scan is a real, live AI query with web search enabled — the same call your customers' assistants make — and a single search-grounded answer takes 30–90 seconds to generate. That time is the AI provider thinking, not the platform working; no tool can make a model answer faster. A full scan is prompts × engines × passes of those checks, run several at a time, so a thorough configuration takes real minutes. The scan bar shows honest progress: how many checks have actually saved, a live time-remaining estimate, and — if any checks fail — how many, with the reason. On the Prompts page, click the failed-checks badge for a per-engine breakdown of what failed and why (it is almost always one provider's key or quota, which is why every prompt loses exactly one check). A failed check is attempted up to 3 times and saves no run — it never counts against a Managed AI allowance, and on your own keys a provider call that fails isn't billed by the provider either. You don't need to watch it. Close the tab whenever you like — the scan continues on our servers and your results are waiting next time you open the project. You'll get one summary email the moment the scan finishes — wherever it finishes, and never more than one. (A scan you stop yourself doesn't email; you were there.) Most other AI-visibility tools only run prompts on a fixed overnight schedule, so their dashboards always show yesterday's data and there is nothing to wait for — but also no way to measure right now. CrunchJunkie gives you both: the automated schedule (weekly, daily, or every N days — pick the rhythm and the hour; most teams pick early morning so fresh numbers are ready with the first coffee) for routine tracking, and the on-demand scan for the moments you need an answer today — after a site change, before a client call. Use the schedule as your default and the manual scan as your instrument, and the waiting disappears from the workflow entirely.

A visibility line steps and, weeks later, nobody remembers why. Was it a real change, or did you add two engines, switch the market, or pause scanning that week? Timeline notes put the answer on the chart itself. We record configuration changes automatically. Whenever something changes that genuinely moves the numbers — market, answer language, engines added or removed, prompts added or removed (including through the MCP connector), passes per prompt, scan frequency, competitors, brand aliases, or pausing and resuming — a note is written against that date. Deliberately nothing else: a note on every save is a note people stop reading. The same rule shapes repetition: adding ten competitors or ten prompts across a day merges into one note naming them all, and a change undone the same day leaves no note at all — the measurement ends the day where it began. The wording explains the statistics, not just the setting. Adding a competitor says Share of Voice will step even if nothing about your brand changed, because it is measured against a different set of brands from that date. Pausing says the line has a gap rather than a decline. You add your own for everything else — "client launched a TV campaign", "site migration", "new pricing page". Backdate them to the day the thing happened, which is usually not the day you write them down. On the chart, notes appear as small markers on the date axis; hover to read one. Several on the same day cluster into a single marker with a count. Your notes and ours are different colours, so you can tell at a glance which is which. Manage them all under the project's Settings tab, where automatic ones can also be dismissed once you have taken them in. Automatic notes are internal and stay internal. "Market changed from United States to Spain" is a correction you made to the measurement, and it has no place in the report your client reads. Your own notes are internal by default too — you can promote one to appear in client reports and share links, but nothing is ever shown to a client unless you deliberately choose it. One more thing the notes do: when a configuration change falls inside the period you are looking at, the chart says so. A period-over-period comparison across that date is comparing two different measurements, and we would rather tell you than quietly show you a number that looks like a result.

Four headline metrics tell you how you're doing. Visibility % is how often your brand appears across all tracked prompts. Share of Voice is your slice of total brand mentions versus your tracked competitors — the clearest signal of who owns the conversation. Sentiment scores how positively each mention describes you, and Average Position records where you land when you do appear. Drill into any metric by model, by prompt category, or over time. The Responses view lets you filter to All, Mentioned, Not mentioned, or Mention gap (prompts where a competitor appears and you don't) — the fastest way to find concrete opportunities. The Sources view ranks the domains AI cites most, and the Insights view turns all of this into prioritised, plain-language actions. Those four metrics tell you how often and how prominently you appear; the Perception view (under Brand in the nav) tells you what the models actually said — the descriptive terms they used about each tracked brand, and which of those terms are used for you and nobody else. See the Perception guide for how to read it.

You don't have to keep checking the dashboard to catch a problem. CrunchJunkie watches each project's scans and emails your team when something material changes — specifically, when your brand's visibility drops sharply between two scans, or when a competitor overtakes you in Share of Voice. The alert names what moved, by how much, and links straight to the project so you can act on it. The thresholds are deliberately set to flag real movement rather than scan-to-scan noise: a drop only alerts when it's a meaningful relative fall from a non-trivial base, so you're not pinged every time a number wobbles by a point. Each project alerts at most once per change so your inbox stays calm, and alerts ride on the same daily scan cadence you've configured — no extra setup, and nothing to switch on.

A single overall visibility number hides where you actually win and lose. CrunchJunkie classifies every prompt on two axes so you can slice it. Buyer intent — Commercial (comparing/buying), Informational (learning) or Navigational (looking for a specific brand) — is auto-predicted for each prompt and stays editable. Branded vs non-branded is derived deterministically from your brand name and its aliases: a branded prompt names you ("is Lumière any good?"), a non-branded one is a pure category question ("best CRM for agencies?"). Both classifications are rule-based, not an opaque model guess, so they're instant, free and 100% reproducible. On the Prompts page these become one-click slice filters. Each slice chip shows that slice's visibility with its sample size (for example "Non-branded 34% · 340 runs"), so a slice built on three runs never reads like one built on three hundred — the number always carries its confidence. The distinction that matters most: high branded visibility just means AI repeats what you already told it, while non-branded visibility is the real prize — being recommended when the buyer hasn't named you yet. Slicing by Commercial intent shows exactly the purchase-moment queries where a recommendation converts. Because that difference is so easy to miss, the Overview watches for it: when a large share of your prompts name your brand (or branded prompts materially lift the headline number), it shows an inline flag with your non-branded visibility right there — so a visibility figure that looks high only because you're asking about yourself by name can't be mistaken for genuine, unprompted recommendation.

A fair question, and worth being precise about. CrunchJunkie's scans are independent of your own AI-account history: we don't query the ChatGPT or Gemini consumer apps (which carry memory, custom instructions, chat history and your location) — we call the providers' APIs, where every request is stateless. Each scan sends only the prompt plus a web-search tool; there is no memory, no prior conversation, no personalisation, and this is true whether the scan runs on your own key (BYOK) or on Managed AI. Your account, your searches and your history never leak into the result. The provider doesn't tailor an API answer to whoever owns the key. So when a brand's visibility looks surprisingly high, the cause is almost never bias — it's usually prompt design. A prompt that names the brand ("What are Acme's strengths?") practically guarantees a mention, which lifts the headline number without proving the brand is recommended. That's exactly why we separate branded from non-branded (above) and surface the non-branded figure: it's the honest, bias-free signal, and the right number to track over time and to compare against other tools. If two tools disagree on a brand's visibility, the usual reasons are different prompt sets (branded vs unbranded), different model versions, and different numbers of runs — not one being "biased".

Not every AI answer is built the same way. On the Responses view you can filter by the features an engine actually used to produce an answer. "Web search" marks answers where the model retrieved live web sources before replying (grounded) rather than answering from its training memory — and the ungrounded answers are exactly where hallucinated or outdated brand claims tend to hide, so filtering to them is a fast way to audit risk. "Shopping" marks answers where the engine returned product recommendations. These flags are derived only from signal the provider genuinely exposes — the sources a model retrieved, and the products it recommended — never inferred or faked. We deliberately don't claim features our provider APIs don't report (such as ads or maps blocks): honest, verifiable coverage matters more than a longer feature list. Each response also shows its feature tags inline, so you can see at a glance how a given answer was assembled.

Winning the first answer is only round one. Real buyers keep talking: "best CRM for startups?" becomes "which of these is best for a small team?" — and a brand can win the broad recommendation and vanish the moment the ask gains one constraint. Follow-up survival measures exactly that. For a tracked prompt you write one realistic follow-up (the "narrower"); during the scan, right after the engine answers the original prompt, CrunchJunkie asks that follow-up in the same conversation and records whether your brand — and each competitor — survives into the second answer. The Follow-up view then shows survival rates with the sample sizes behind them, and the exact conversations where you dropped out and someone else took the slot. A few honest mechanics. It's opt-in per project (AI Visibility → Settings → Follow-up survival) because a follow-up is a real second run: eligible prompts cost roughly twice as much, and every turn-2 is counted and metered exactly like any other check. Only prompts with a configured follow-up get one — we never invent the question — and only conversation-capable engines take part: the direct-API engines carry the conversation, while the search-capture engines (Google AI Overviews, AI Mode, Copilot) and DeepSeek have no multi-turn channel and are honestly left out. The follow-up is asked in the project's language, the second answer runs through the same mention extraction as the first, and each turn-2 stores the exact follow-up text it used as immutable evidence. Read the metric the way it's built: not "how visible am I?", but "when a real buyer narrows the ask, am I still in the room?" — a question no other visibility tool currently measures.

When an AI model answers a prompt it often cites the pages it drew on, and CrunchJunkie records every one. The Sources view ranks the domains cited most across all your prompts and models — the sites that are actually shaping what AI says about your category. The URLs view goes a level deeper, listing the individual pages cited and how often each appears, so you can see exactly which articles, listicles or product pages the models lean on. Gap analysis turns this into a to-do list. It surfaces the domains where AI cites a competitor but never you — your clearest content gaps. Each gap is a concrete opportunity: earn a mention on that source (a review site, a directory, an industry roundup) and you start appearing where buyers are already being pointed. Because all three views are built from real scan citations, they update every time a scan runs. The URLs view also surfaces "Cited in AI, not (yet) winning in Google": your OWN pages that AI engines cite as a source but that rank low — or don't appear at all — in Google organic. It joins the AI citations to each page's average Google position across every Search Console property connected for the client (last 90 days), so you see the pages winning in AI before they win in Google — the ones to double down on. It reads all connected properties, not just one, so a page whose rank lives in a different property (a domain property vs a www / non-www prefix) is still matched. It's deliberately honest: Google's position is an impression-weighted average across queries (not a fixed rank), "No Google data" means no impressions in the window on the connected property — the page may not be ranking yet, OR that property doesn't cover the URL (e.g. a www-only property when the page lives on the bare domain) — and homepage / host-only citations that can't be matched to a specific page are counted separately. If most cited pages show no Google data, that's usually a sign the property covering the domain isn't connected, and a note points you to fix it. It needs Search Console connected for the client. Both the Sources and URLs tables carry a brand-mention filter with Any / All / None logic, so you can slice the citation set precisely. "Any of" shows sources cited in runs that mentioned at least one selected brand; "All of" shows only sources cited in runs that named several brands together — the fastest way to find a page that talks about you and a competitor at once; and "None" shows sources cited where no tracked brand was mentioned — untapped places not yet talking about anyone you follow. At the top of the Sources view is a Source health check. AI answers cite live web pages, and two source-quality problems are worth catching when they concern your brand: a dead link (a cited page that now returns HTTP 404 or 410 — it no longer exists) and a retracted source (a cited URL whose DOI is confirmed retracted by Crossref, which integrates the Retraction Watch database). Click "Check sources" and CrunchJunkie verifies the individual pages AI cited and flags any that are dead or retracted, with the exact status or DOI. It is deliberately conservative and accuracy-first: only a definitive 404/410 is called dead (a network hiccup never is), and retraction only covers academic DOIs — so it's most useful for health, science and research-cited brands, and simply shows nothing to flag for everyone else. Results are cached per URL and checked in bounded batches, so the check stays fast and cheap; re-run it any time to re-verify. The Query fanouts view shows the step BEFORE the citations: the web searches each engine actually ran before answering your prompts — the "fan-out". These are captured verbatim from the engines' own search tool calls during your scans (measured, never estimated), and they're the queries that decide which pages get read and cited, so they are what your content should rank for — not just the prompt wording itself. Coverage is stated honestly on the page: fan-outs exist only from new scans onward, some engines never expose their searches (that's a provider trait, not evidence they didn't search), and Google AI Overviews, AI Mode and Copilot have no fan-out by construction — there, the prompt is the search. Deliberately absent: search-volume figures. None exist for AI fan-outs, so none are shown. Each search also shows where you stand in its outcomes, so you know which fan-outs to fix first. "You in the answers" counts, over exactly the answers that ran the search, how many cited your domain and how many named your brand — measured from real citations, never modeled — and the table's default order is plain subtraction: the searches shaping the most answers without you come first. "Cited instead" lists the third-party domains those same answers actually cited — who owns the search today; one dominant domain is a clear target, a fragmented field is a winnable search. And when Search Console is connected, a Google column joins your own average position and impressions for the exact search string — real Google data, labeled as such. A search where you already rank in Google's top 10 but AI answers never cite you is the highest-leverage fix of all, and it's flagged right on the row: the content exists, it just isn't being cited. A dash there means the query isn't in your Search Console data for the window (Google anonymizes rare queries) — never proof you can't rank. Each row links straight to the Content Brief for the prompt that triggers the search most. One-click views above the table narrow it to the searches that never cite you or to the rank-but-uncited set, alongside a free-text filter and a minimum-answers threshold for cutting the long tail of one-off searches.

Before an AI can mention a brand, its crawler has to be allowed to read the site. The Crawlability tool checks a domain's robots.txt against every major AI crawler — GPTBot and OAI-SearchBot (ChatGPT), ClaudeBot and Claude-SearchBot, PerplexityBot, Google-Extended and Googlebot, and more — and tells you whether each is Blocked, Partial or Allowed. Expand any crawler to see exactly why (which user-agent rule matched) and how to change it. The tool distinguishes training crawlers (blocking them keeps your content out of model datasets, often intentional) from search and answer crawlers (blocking these directly hurts your AI visibility), so you can make the right call per bot. The domain pre-fills from the client's saved website. The Crawlability check also re-runs automatically on the same weekly cadence as the GEO Audit, so its history and change-log stay current without a manual click — a new snapshot is logged only when robots.txt posture actually changes, and a badge on the page shows when it was last checked (amber if a check ever goes stale, older than about a week). Crawl insights is the companion view: once you forward your server logs, it shows how often each AI crawler actually visits the site — turning "we allow GPTBot" into "GPTBot fetched 40 pages last week". Together, Crawlability tells you who can read the site and Crawl insights tells you who is. One important caveat, because it trips people up: crawler visits show whether AI bots can reach you — not whether you're cited in AI answers. A model often mentions a brand from its training memory without a fresh crawl, and live answers usually cite from an index or cache rather than hitting your server per question, so low (or even zero) crawler visits don't mean low visibility. For whether you're actually being cited, use AI Visibility; Crawl insights is the access-side signal, not a citation count. The top-pages table connects the two sides per page: next to each crawled path, Read shows how many scan answers pulled that page while researching and Cited shows how many cited it as a source — each counted once per answer, matched to your site by page path, and only from answers that expose the genuine retrieved-vs-cited split. The two columns deliberately have different denominators — several engines expose citations but never their retrieved list, so Cited can exceed Read without anything being wrong; the footer under the table states both counts. Below it, "Cited in answers, not crawled in this window" lists your pages AI answers cite without any recent crawler visit — the norm, not an anomaly, for exactly the index-and-cache reason above. The one pattern worth acting on: a page bots fetch heavily that never gets read into an answer is content the models collect and don't use. When enough pages carry both events, a "Time to citation" line appears: the observed median lag between a page's first logged crawl and its first captured citation, with per-engine medians once at least three pages qualify. Observed is the operative word — both series begin when you connected logs and when citation capture started, and engines differ widely, so read it as what happened on this site, never as a promised speed; pages cited before any logged crawl are counted separately, for the index-and-cache reason above. "Broken for AI crawlers" is the per-page repair list: every URL that answered an error to an AI-bot fetch — dead links (404/410), server errors, rate limits — with the exact status counts and the bots that hit it. Deliberately absent from it: 403/406 edge blocks, because those are access policy rather than breakage and live in the Firewall & Access view — mixing the two would make intentional blocking read as a bug. Once logs are flowing, Crawl insights leads with AI Bot Traffic — the same hits grouped by the company behind the bots rather than the individual user-agent. It shows how many providers reached the site, total AI fetches, the share each provider took (a stacked bar — OpenAI vs Google vs Anthropic vs Amazon…), and the split between user-request fetches (a bot pulling a page live for someone's question) and search-and-training crawls. It's the fastest read of who is paying attention to the site and why. A provider groups all of its bots together (so OpenAI folds GPTBot, OAI-SearchBot and ChatGPT-User into one row), and every share is the provider's hits over the total, so the bars always add up to 100%. Each provider also carries a Verified level — the share of its fetches we could confirm came from that company's own published IP ranges. Some providers (OpenAI, Google, Perplexity) publish machine-readable IP-range feeds; we fetch and cache them and check each hit's source IP against them. A request claiming to be GPTBot from an IP outside OpenAI's published range is a spoofed user-agent and is never counted as verified. Providers that don't publish ranges are shown honestly as unverifiable rather than guessed — so a missing Verified score means "no way to check", not "fake". It's the difference between "a bot said it was ChatGPT" and "it provably was". Connecting the logs takes one of three routes, all on the Crawl insights page. On Vercel: Team settings → Drains → Add Drain → data: Logs → project: the one serving this site → sources: Functions, Edge Functions and Static Files → environment: Production → destination: paste the ingest endpoint shown on the page (JSON or NDJSON format — verification passes automatically). On Cloudflare: Logpush is an Enterprise-only feature, so on the free or Pro plan add a small Worker instead — deploy a forwarder (Workers & Pages → Create → Start with Hello World → paste → Deploy) and attach a Route at yoursite.com/*. The ready-to-paste snippet, with your ingest endpoint already filled in, is on the Crawl insights page under "Forward logs with a Worker." (Enterprise users can still use a Logpush job pointed at the same endpoint.) Anywhere else: upload a .log, .txt, .csv or gzipped .gz access-log file (combined/common format) with the Upload button — .gz files are decompressed in your browser, so a raw server log like sslaccesslog.gz uploads as-is. Privacy note either way: only AI-crawler hits are stored (bot name, path, status, time); human visitors' requests are discarded on arrival and never persisted.

AI crawlers do three different jobs, and blocking them has three different price tags. TRAINING crawlers collect content for future model training: OpenAI's GPTBot, Anthropic's ClaudeBot, Google-Extended (Google's AI training opt-out), Applebot-Extended, Amazonbot, Meta-ExternalAgent, ByteDance's Bytespider, and Common Crawl's CCBot — whose dataset feeds many models at once, so blocking CCBot opts you out of more than one company's training. Blocking a training crawler removes your content from what FUTURE models know from memory. It costs nothing visible today and doesn't touch live answers — it's a legitimate policy choice — but it compounds quietly: models that never read you cite you less from memory later. SEARCH crawlers feed the live-answer index that citations come from: OAI-SearchBot (ChatGPT search), Claude-SearchBot, PerplexityBot, Amzn-SearchBot, Applebot (which also powers Siri and Spotlight), Google-CloudVertexBot. Blocking these is a direct, immediate visibility cost — the engine can't retrieve your pages when composing answers, so it cites someone else. USER-TRIGGERED fetchers act only when a person asks: ChatGPT-User, Claude-User, Perplexity-User, Gemini-Deep-Research, meta-externalfetcher, DuckAssistBot, Mistral. Blocking these makes "read this page" fail live, in front of the exact user who asked about you. One special case outranks all of this: Googlebot itself feeds both classic Search AND AI Overviews — controlling AI use of your content is what Google-Extended is for; blocking Googlebot for GEO reasons would take your Google Search visibility with it. Two traps are worth knowing. First, most "block all AI" robots.txt recipes take out the search and user-triggered crawlers along with the training ones — paying the immediate visibility cost to get the training opt-out, usually unintentionally. The Crawlability tool separates the two classes per bot precisely so you can block training crawlers while keeping the live-answer ones. Second, a User-Agent string is trivially forged: anyone can send "GPTBot" in a request header, and in real production logs a large share of claimed AI-crawler traffic is exactly that. The only trustworthy identity check is the provider's own published IP ranges. OpenAI (openai.com/gptbot.json and companions), Google (developers.google.com's crawler IP feeds) and Perplexity (perplexity.ai/perplexitybot.json) publish machine-readable feeds; Crawl insights checks every logged hit claiming those providers against the live feeds and marks it verified or spoofed. Providers without a confirmed machine-readable feed are marked UNVERIFIABLE — deliberately: some vendors document reverse-DNS lookups instead, and where we can't verify against an official source we say so rather than guess, because a wrong "spoofed" would smear a legitimate crawler. The Crawler identity verification card on the GEO Audit page shows your own verified-vs-spoofed split from your forwarded logs.

Everything above can go into a report. Add a Table widget, choose the AI Visibility source, and set its dimension: Brand, Model, Brand × Model, Perception, Prompt, Gap analysis, Cited URLs, Crawler visits, AI bot traffic, Crawler access, Tag, Topic, Biggest Movers, Cited Sources, Source Performance, Source Health, Retrieval & Citations, plus the shopping set (Shopping, Product, SKU, Product Schema, Feed Readiness, Shopping Sources) covered in the AI Shopping Visibility guide. Every one of them reads the report's date range and carries its sample size, so the client sees the same honest numbers you do. "Gap analysis" puts the content-gap list in front of the client. Each row is a domain the models cited, with four figures: "Cited with competitor" is the number of scan runs where that domain was cited and a competitor was mentioned, "Cited with you" is the same count for the client's own brand, "Gap" is the first minus the second, and Runs is how many runs the domain appeared in at all. A domain counts at most once per run — ten citations of the same site inside one answer is one appearance, not ten — so the figures read as reach rather than repetition. Only rows with a positive gap are shown: a domain that cites you as often as your rivals isn't an opportunity, and neutral rows would bury the ones worth acting on. One difference is worth knowing before a client asks about it. The Gap analysis page inside the app looks at every run ever recorded, because it's a working tool and you want the complete list of gaps in front of you. The report widget honours the report's date range instead, because a client report covers a period. So the same project can legitimately show more domains on screen than in last month's report — that's two tools answering two different questions, not a discrepancy to chase. "Prompt" breaks results down by the individual question rather than rolling them up. Tag and Topic group prompts together, which is the right grain for a theme and the wrong one for "when someone asks this exact question, do we appear?" — the question clients actually ask. Rows are sorted worst-first, because a report about AI visibility is more useful opened on the questions you are losing than the ones you already win. "Cited URLs" is the page-level counterpart to Cited Sources. Cited Sources is domain-only, so a Reddit thread, a review article and a forum post all collapse into "reddit.com" — right for "which sites matter", wrong for "which page do we need to get onto". Each row is an actual URL with a rough page type, how often it was cited, and whether your brand or a competitor was mentioned in those same answers. "Crawler access" is the bot-by-bot robots.txt posture, sorted blocked-first so problems surface at the top. Note it is NOT date-ranged like the others: it reads the most recent crawlability check, because robots.txt posture is a current state rather than something that accumulates over a period. Showing it as of an arbitrary past date would be misleading, since it may well have been fixed since. "Crawler visits" is the other new table, and the one piece of AI-visibility evidence that is measured rather than sampled: it lists the AI crawlers that actually fetched pages from the site, read from server logs. It needs crawl-log ingestion set up for the project first — see the AI crawlers & crawlability guide for how it works and what an empty table means. "AI bot traffic" is the provider-level version of that table: one row per company (OpenAI, Google, Anthropic, Amazon…) with its total fetches, its share of all AI fetches, and the split between user-request and search/training crawls. It's the same summary the Crawl insights page leads with, so the report and the app always agree. Like Crawler visits it's measured from server logs and needs ingestion wired up first. The GEO Audit source adds one more: a "Competitor crawler access" table that benchmarks your robots.txt against your competitors' — one row per AI-answer crawler showing whether YOU block it and how many of your competitors do, so "you block ChatGPT while most competitors allow it" jumps out. It's populated once you add competitor domains in the AI-visibility project's settings (only domains you enter are checked), and it renders in the app, on shared links and in the PDF. A competitor whose robots.txt can't be read is left out rather than guessed at. The GEO Audit source also has a "Firewall & access policy" table. Where "Crawler access" reports only what your robots.txt says, this one joins that with a live probe: it fetches your homepage with each AI-answer crawler's user-agent and checks whether the request actually got through. The column that matters is the verdict — "Firewall blocks" means your robots.txt allows the crawler but a firewall or CDN refuses it anyway (an HTTP 403/406 the crawler hits before robots.txt is ever consulted), so the crawler can't read or cite you no matter what robots.txt says. It fills in after a GEO audit runs a conclusive probe, covers the five crawlers a block can be pinned to (ChatGPT's OAI-SearchBot and ChatGPT-User, PerplexityBot, ClaudeBot, Googlebot), and renders in the app, on shared links and in the PDF. A bot-challenge or rate-limit is shown but never counted as a confirmed block.

Larger projects benefit from a little organisation. The Brands view manages the exact names CrunchJunkie matches as mentions — your client plus its competitors — including spelling variations and aliases, so a mention is never missed or miscounted. Tags let you label prompts (by theme, funnel stage, or client priority) and then filter every metric by tag, which is the fastest way to answer questions like "how visible are we on bottom-of-funnel comparison prompts?". Project Settings is where you control the brand name and website, the competitor list, which models run, runs-per-prompt, and the scan schedule. Scheduling is off, daily, or weekly — and you pick the exact time (and, for weekly, the day) it runs, in your own timezone, so scans land when you want them. Changes here apply from the next scan onward.

Already tracking AI visibility in Peec AI? You can import a Peec project straight into CrunchJunkie instead of running native scans for that client. Under Data → Integrations, open Connect on the Peec AI card, choose the client, and paste a project-scoped Peec API key (created in Peec under Account → API Keys). CrunchJunkie verifies the key, then imports the project's visibility, share of voice, sentiment, average position, prompts and cited sources. Once imported, the data populates the exact same AI Visibility screens and report widgets as native scans — Overview, Prompts, Sources, Gap analysis and the report builder all work unchanged. The project is marked as Peec-sourced so the origin of the numbers is always clear, and re-syncing pulls the latest figures. Note that Peec's REST API is currently part of their Enterprise/beta tier, so the key needs API access enabled on their side.

Peec-imported data and CrunchJunkie's own (native) scans live side by side on the same client without clobbering each other. Every data point is tagged with its origin — "peec" or "native" — and the two are stored under different model names (Peec uses friendly labels like "ChatGPT" and "Perplexity"; native scans use the specific model versions they call, e.g. ChatGPT on GPT-5.6 with web search, or Perplexity Sonar Pro). Because of that they never overwrite one another: running a native scan adds native data alongside the imported Peec data rather than replacing it, and a Peec re-sync only refreshes its own imported rows. When a client has both, the AI Visibility overview shows a source switch — All / Native scans / Peec AI (imported) — so you can view either source on its own or together. One thing to keep in mind: in the combined "All" view the same assistant can appear twice (once from Peec, once from a native scan), so for a single client it's best to treat one source as your source of truth and use the switch when you want to compare. A Peec-imported project won't start native scanning on its own — it has no native prompts and its scan schedule stays off until you add prompts and choose to run them.

Settings → Billing shows a usage ledger under the Managed AI meter: every check this period, broken down three ways — by client, by engine, and by day. It shows two numbers side by side, and the difference between them matters. Scans is how many times we actually queried an engine. Checks used is what that deducted from your allowance. They are not the same, because premium engines (ChatGPT, Claude, Perplexity, Grok) count 3× — so 200 scans on ChatGPT is 600 checks. Premium engines are marked with a ×3 badge, and when the two numbers differ the ledger states the reconciliation outright: "N scans became M checks once premium engines were weighted." Managed checks and your own-key checks are listed in separate columns and never added together. Managed checks draw down the package you pay for; own-key checks run on your API key and cost you nothing here. A single combined number would not describe anything real. Use it to answer the questions the meter alone cannot: which client is consuming the package, whether a premium engine is worth what it costs on a particular project, and whether a spike was one bad day or a steady climb. There is a PDF export for passing the breakdown to a client or into an expense system. Checks recorded before July 2026 have no client attached and appear as "Not attributed" — they are shown rather than dropped, so the parts always add up to the total.

You can run scans two ways. Bring-your-own-keys lets you connect your own API keys for each model; CrunchJunkie runs the scans through them and you pay only the providers' usage rates, with no markup. Keys are encrypted at rest and used solely for your scans. This is the most cost-effective option if you already have provider accounts. Managed AI is the no-setup alternative: CrunchJunkie runs the scans on our own infrastructure, with no keys to manage. It is metered by check (one check = one prompt, run once, on one engine — the scan and its follow-up analysis count together as a single check). You pick a monthly package with an included check allowance, from €25/mo (Lite, 645 checks) up to €399/mo (Scale, 12,250 checks), and pay €0.05/check beyond it (all excl. VAT). Efficient engines count 1× per check; premium engines (ChatGPT, Claude, Perplexity, Grok) count 3×, because they cost about three times as much to run — so 100 scans on ChatGPT uses 300 checks, not 100. There is no limit on how many prompts you track, on any plan. Cost is governed by the check allowance, which measures what actually drives it: prompts × engines × passes. Unused checks roll over. Whatever is left at the end of a month is carried into the next one and spent only after that month's fresh allowance, so nothing you paid for expires while you still hold the package. The balance accumulates up to six months' worth, and is forfeited if you cancel Managed AI — it is a benefit of holding the subscription rather than stored credit. During the free trial we cover a single Managed engine (Gemini) so you can see real data before paying for anything. When the trial converts, that access becomes a Managed AI package — or, if you would rather not have one, add your own API key and keep scanning at no markup. You can mix Managed and your own keys, turn individual engines on or off, and set a spend cap that pauses Managed scans before a bill surprises you (your own keys keep running, since we never cap what you pay for directly). See the pricing page for current Managed AI details.

The unit is the check. One prompt, asked once, on one engine, is one check — unless it's a premium engine (ChatGPT, Claude, Perplexity, Grok), which counts as three. Every total below is just that, multiplied out: prompts × passes × the sum of the engine weights. One scan. Say you track 10 prompts and run them on four engines — ChatGPT and Perplexity (premium, 3× each) plus Gemini and Google AI Overviews (efficient, 1× each) — at two passes. One pass of one prompt is 3 + 3 + 1 + 1 = 8 checks; two passes is 16; across 10 prompts, a single scan is 160 checks. One month. Scanned weekly, that's about 4.3 scans a month ≈ 690 checks. Scanned every second week, about 345. Against a package. Managed AI Lite includes 645 checks for €25/mo. The every-second-week cadence (≈ 345/mo) sits comfortably inside it, and the unused ≈ 300 checks roll into next month. The weekly cadence (≈ 690/mo) runs about 45 over: those are billed at €0.05 each — €2.25, so €27.25 that month (excl. VAT, like every Managed AI figure) — unless you've banked rollover, which is always spent before any overage. Unused checks bank up to six months' worth. The cheapest pulse. Lite scan mode — two efficient engines at one pass — is just 2 checks per prompt per scan. Tracking 20 prompts weekly is 20 × 2 × 4.3 ≈ 172 checks a month, well under a third of the Lite allowance. Two things never cost you a check: there's no limit on how many prompts you track (only scanning them draws down the allowance), and a failed check — retried up to three times — is never counted, on Managed AI or on your own keys. On your own keys none of this is metered by us at all: you pay each provider's rate directly, and the same formula just tells you what to expect on their bill.

Before setting up a full project, anyone can try a quick version at /ai-visibility-check on the marketing site — no account, no signup. Enter a brand (and, optionally, up to three of your own prompts and an email for the fuller write-up), and CrunchJunkie runs a small, real scan on the spot: it queries a single web-grounded AI model a handful of times and reports how often the brand was mentioned as a Visibility %, with the exact sample size ("n = … runs") and a boundary-safe margin of error (± %), plus any real sources cited. It's deliberately a small sample on one model, and the page says so — it's an honest snapshot, not a fabricated score, and if a run or two fails the number is recalculated on what actually completed. It's a good way to show a prospect what AI is saying about them in under a minute; the full product tracks continuously across all ten models with many more prompts, competitors, sources and trends over time. Use it as a lead-in, then create a project to go deep.

If you open ChatGPT (or Gemini, Perplexity) on your phone, run one of your prompts, and compare it to a CrunchJunkie scan, the answers usually won't match exactly — and that's expected. AI answers are non-deterministic and personalised, so a single manual check and a controlled scan measure different things. Five reasons they diverge: • Different model. The consumer ChatGPT/Gemini/Perplexity apps use whatever default model and built-in web search your account gets. CrunchJunkie scans a defined list of specific model versions via their APIs (e.g. ChatGPT on GPT-5.6 with web search, Perplexity Sonar, Gemini, Google AI Overview). Different model, different answer. • Personalisation. Your app carries memory, custom instructions, account history and your location — all of which bias the answer (e.g. toward agencies near you). Scans run clean and neutral, with no personal memory, against the market you configure, so results are comparable across clients and over time. • Live browsing. When the app browses the web, it pulls fresh results that change minute to minute. A scan captures a controlled snapshot. • Sampling. The same prompt returns different answers on repeat runs, because models sample. That's why CrunchJunkie runs each prompt several times and aggregates — one manual run is a single noisy sample. • Time. Models and the web index change constantly; a scan from last week and a check today will differ. The takeaway: a manual spot-check is one personalised, noisy data point. CrunchJunkie's value is the controlled, repeatable, multi-run measurement that averages out that noise — so you can track the trend and compare brands fairly, rather than reacting to a single screenshot.

A visibility line steps and three weeks later nobody remembers why. Was it a real change — or did you add two engines, switch the market, or pause scanning for a week? Timeline annotations answer that on the chart itself. CrunchJunkie writes most of them for you: whenever a project setting that affects measurement changes — market, language, engines, competitors, brand aliases, prompt set, passes per prompt, schedule, or scanning paused/resumed — an automatic annotation is recorded with the exact before/after. Changes that alter what is measured (market, language, engines, competitors, aliases, prompts) are flagged specially, because a delta that spans one of them compares two different measurements. You can also add manual notes — "new pricing page live", "PR campaign started" — from the annotations panel on the visibility timeline. Every annotation is internal or shared, and the rule is strict: automatic annotations are always internal — your clients never see your configuration changes. A manual note you mark as shared appears in client-facing reports too: as numbered notes beneath the AI-visibility charts in the in-app report, the shared report link, and the PDF, so the client reads the same explanation next to the same line. Internal notes stay visible only inside the app.