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.

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 six chat models (ChatGPT, Gemini, Perplexity, Claude, Grok, DeepSeek) 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.

A project produces one headline visibility figure, calculated across every run in it. So if you put German and English versions of the same question in one project, that figure describes neither audience — it averages two different markets into a number that answers nobody's question. It also doubles what each scan costs, because every prompt is billed per run per model. If a client sells into two language markets and you want both measured, tag the prompts by market — for example `de` and `en` — and build report widgets filtered by tag. A tag filter recalculates the metrics over only the matching answers, so each widget gives you an honest per-market number. The project's own headline figure still covers everything, so read the tagged widgets rather than the top-line when you are reporting per market. Do not split one brand across two clients to separate markets. It bills twice for the same brand, splits the reporting, and describes one company as two.

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. 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 nine AI surfaces: ChatGPT, Gemini, Perplexity, Claude, Google AI Overviews, Google AI Mode, Microsoft Copilot, Grok, and DeepSeek. Enable the ones that matter for your client's audience under the project's Models settings — you don't have to run all nine. 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, and Google AI Overviews and AI Mode through a search-results provider. Eight of the nine 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 nine 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.

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 or daily, at the hour you set — 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 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.

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. 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.

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. 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: create a Logpush job for HTTP requests 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.

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.

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, 600 checks) up to €399/mo (Scale, 11,400 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 three 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.

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 nine 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.