Visibility
Prompts
What a prompt is, how it differs from a keyword, how the ones you track get run, your figures and the leading brand on each one, countries, cities and buyer-persona audiences, the Google results card (shown rate and organic rank next to Overview citations), bulk organization, reviewable AI classification and prompt branding, and the Google demand behind it.

What a prompt is
A prompt is a full question, stored as its own row, that DiscoveredBy actually runs against the AI engines you track, not a fragment of one. A keyword is a different thing: a plain text label belonging to the project, which you can attach to a prompt to file it, with no country, no schedule, and nothing that runs it. See Key terms for how a prompt fits the rest of the product's vocabulary.
Admin prompt directory
Platform admins can narrow Admin > Prompts by project and by Active or
Inactive status, alongside the prompt text search. Choose the filters and
click Apply filters. The count and pagination reflect the combined filters;
Clear returns to all prompts. The project picker includes every project
and shows its ID to distinguish projects with the same name
(api/routers/admin.py#list_admin_prompts, api/routers/admin.py#admin_project_options).
The Web citations column shows each prompt's all-time citation occurrences
across completed runs, targets and engines. A source cited in two runs counts
twice. Prompts with no recorded web citations show 0. Shopping and local
business references are tracked separately and do not increase this count
(api/routers/admin.py#list_admin_prompts).
Admins can choose Run now on one row or select prompts on the current page
and choose Run selected, then Confirm run now. This queues fresh checks
for eligible active targets using the engines on the company's plan and the
prompt's engine choices. Each run creates a separate execution and keeps all earlier
answers, references, citations and analysis in history. Daily metrics use the
latest successful outcome for each target, engine and day, including a valid
No AI answer result. Failed or still-running retries leave the previous
successful result in use. Checks already running are skipped. The admin
Web citations total includes every stored completed run, including same-day
reruns, so it can be higher than the citations used in daily metrics
(api/services/execution.py#_create_execution_record,
api/services/execution_reads.py#daily_execution_filter).
Inactive prompts cannot run. The response reports queued checks, skipped
prompts and any queue failures, with a link to Prompt Executions. Requests
are recorded in the admin audit log and limited to 50 prompts and 1,000 engine
checks per selection (api/routers/admin.py#run_admin_prompts,
api/services/admin_prompt_runs.py#queue_admin_prompt_runs).
In Admin > Prompt Executions, opening an execution renders its LLM
response as Markdown, including headings, lists, links, tables and code blocks.
View raw Markdown shows the original response text for inspection. Embedded
HTML is sanitized before display
(frontend/src/routes/(admin)/admin/executions/[id]/+page.svelte#responseHtml).
The execution list and detail show Used for daily metrics on the selected
valid outcome and Previous run on an older valid outcome. Failed or running
reruns show Not used for daily metrics and link to the retained daily result.
When no valid result exists, the latest attempt shows No valid result yet;
it represents collection status only. Selection always considers the full
history, even when the list is filtered or paginated
(api/routers/admin.py#_admin_daily_results).
DataForSEO requests retry transient errors, including code 40101, up to
three times within an execution (four attempts total). If these fail, the
execution remains failed. Scheduled catch-up sweeps, when enabled by the
deployment, create new attempts only for targets and engines without a valid
result that day. They skip failed reruns when an earlier valid result exists.
For an on-demand retry, choose Retry on a failed row in Admin > Prompt
Executions or on its detail page. This queues only that execution's target
and engine, using the current prompt and target settings for the current
execution day. It creates a new execution and preserves the failed record and
its citations. Inactive or unavailable checks, engines outside the company's
plan, and checks already running are skipped. A queued message confirms that
the job was accepted, not that collection has finished. Retry requests are
recorded in the admin audit log. Run now in the prompt directory remains
available when you want all eligible targets and engines
(api/routers/admin.py#retry_admin_execution,
api/services/admin_prompt_runs.py#queue_admin_execution_retry,
api/services/llm.py#_post_dataforseo_with_retries,
api/tasks.py#_enqueue_failed_retries).
One target per location, audience and language
Every prompt tracks at least one location: a whole country, or a city
(see Cities below). Each location you add creates its own row
underneath the prompt, called a prompt target, and that row, not the
prompt itself, is what actually gets run: a prompt tracked in three countries
produces three prompt targets, each checked independently against every
engine on your plan, or a chosen subset, except that a persona variant, a
Chinese variant and a prompt over 700 characters never run on the two
Google engines (see Google results), and a persona
variant, a city variant, a Chinese variant and a prompt over 2,000
characters never run on ChatGPT (see
ChatGPT runs), and a persona variant, a Chinese
variant and a prompt over 2,000 characters never run on Gemini (see
Gemini runs). Adding a country or a city to a
prompt, or reactivating one you had paused, uses one of the prompt slots on
the company's plan, which pool across every active project in the company;
see Pricing for what each plan includes. The engines offered,
and the "Limit reached" notice when the slots are full, follow the company's
plan too, so someone who also belongs to a company on a smaller plan sees
this project's real engines and limit (api/routers/projects.py#get_project_usage).
A prompt also tracks at least one audience: the plain, unbranded "General"
audience every prompt starts selected with, plus any
personas you add to it. General can be
deselected as long as at least one persona is selected in its place; at
least one audience always has to remain. A prompt can also track more than
one language, "As written" (no translation, just today's behaviour) plus
any of 48 supported languages; a target is now the combination of one
location, one audience and one language, and each combination is its own
slot, so a prompt tracked in 3 countries as General plus 2 personas, all As
written, produces 3 x 3 x 1 = 9 targets, not 3
(api/schemas/prompt.py#PromptCreate, api/routers/prompts.py#create_prompt,
api/services/prompt_variants.py#sync_targets). See
Personas for what a persona changes about how
the prompt is actually run, and
Languages and templates for the
language dimension, choosing which engines run a prompt, and saving a
combination as a reusable template.
Cities
A prompt can also be tracked from a city: London rather than the whole of
the United Kingdom, say. On the Add and Edit prompt forms, a Cities
picker sits under the countries. It lists the cities of the countries
enabled on your project, grouped by country and searchable by city, region
or country (api/routers/projects.py#list_project_cities,
frontend/src/lib/components/CityPicker.svelte#visibleGroups). A city is a
location of its own: choosing Lyon does not need France selected, and does
not add a France-wide target. It is crossed with audiences and languages
exactly like a country, so each city uses one prompt slot for each audience
and language it runs as, and the preview counts it the same way, as in "2
locations (1 country, 1 city)"
(api/services/prompt_variants.py#resolve_spec, #diff_targets,
frontend/src/lib/api/prompt-form.js#locationCountText). A prompt can hold
at most 100 active targets, and city targets count toward that limit
(api/services/prompt_variants.py#MAX_VARIANTS_PER_PROMPT). Cities are on
every plan, with no entitlement of their own: the prompt slots they use are
the cost.
The list is fixed by us, not typed by you. DiscoveredBy seeds 344 major
cities across the 18 countries a project can target, between 15 and 25 for
each country except Singapore, which is a single city. Each one carries
its region and its time zone, which some engines receive with the city
(api/services/cities.py#DEFAULT_CITIES,
How location reaches each engine).
A city you need that is not listed can be added by our team: contact
support with the city and country. Nobody on a project can type a city
name, so no free text you enter ever reaches an engine's location field.
A city must be in a country enabled on the project, or the save is refused
with the city named (api/services/prompt_variants.py#_validate_city_ids).
If you later turn that country off in project settings, the prompt's city
targets keep running, exactly as its country-wide targets there do; the
Edit form shows the city as belonging to a country no longer enabled and
lets you remove it, but not add it again. A city a target still uses is
never deleted from the list.
Cities are set from the Add and Edit prompt forms and from
variant templates,
including bulk-applying a template, which applies the template's saved
cities. CSV and Excel import, accepting a suggestion and accepting a
discovered prompt all add country-wide targets only, and never change a
prompt's existing city targets
(api/services/prompt_import.py#apply_plan,
api/services/prompt_discovery.py#accept_candidate).
A city target's answers are compared with the same country's country-wide answers on the Local page, and City is an Explorer dimension. What a city target means, and does not mean, about where an answer "comes from" is on Engines and measurement.
How prompts get run
In the regular app, running a prompt is not something you trigger yourself, with one exception:
accepting a prompt from Suggestions immediately queues a fast first run
outside the daily cycle (see
Your first scan for
what that exception does and does not change). Otherwise, a single scheduled
job, once a day, enqueues one run per active prompt target, on every engine
currently available on your plan that the target runs on
(api/services/collection.py#target_runs_on). It requires the project, the prompt and
the target all to be active before it will enqueue anything, so pausing a
prompt, or removing one of its countries or cities, removes it from that
job's next run. See Your first scan for how
long the first run takes and what appears once it finishes.
The prompt list
Prompts lists everything you are
tracking. Each row carries the prompt's text, the locations it runs in (a
country code for each country-wide location, then a "City, CC" chip with a
pin for each city; past the first three locations, a "+N" chip lists the
rest when you hover it), its tags and keywords and classifications as chips,
your figures on that prompt and its leader (below), an icon per engine it is
checked against, and a running or paused pill. With Search Console connected
there is also a Google demand column, described below. Three counts sit
above the table: how many prompts are running daily, how many are paused,
and how many countries the project tracks between them, a city's country
included (frontend/src/routes/(app)/prompts/+page.svelte#trackedCountryCodes).
They count prompts, not answers, so the date range and engine never change
them.
Your figures on each prompt
After the prompt come six columns: your Visibility, share of voice
(SoV), average position (Pos.), Win rate and Positive on
that prompt, then its Leader
(frontend/src/lib/prompt-figures.js#FIGURE_COLUMNS). Each figure is your
brand family's, over the prompt's answers that the filter bar's six chips
select, computed by the same definitions as the
Explorer broken down by prompt (see
Metrics defined for each). With no city chosen,
your Visibility and Pos. on a row are the numbers the prompt's own
Brands tab shows for you over the same date range, engine,
country, persona and language. Positive is positive sentiment read on one
engine channel. With no city chosen it is the channel Overview's Positive
sentiment uses for the same filters; with a city chosen, the channel is
picked the same way over that city's answers. The column's tooltip and the
note under the table name it
(api/services/prompt_metrics.py#build_prompt_metrics,
api/services/overview.py#_sentiment_channel).
Under each value is its change against the period of the same length just
before, by the brand ranking's rule: when some engine was not measured in
both periods, the changes of Visibility, SoV, Pos. and Win rate compare only
the engines measured in both, and the note under the table says "Changes
compare only the engines measured in both periods." Positive's change is the
plain difference on its one channel. For Pos. a fall is the better change.
A figure built from fewer than 30 observations carries an asterisk, its
tooltip reads like "Low sample (n = 12 answers)", and the note under the
table explains the mark
(api/services/prompt_metrics.py#_metric_cell,
frontend/src/routes/(app)/prompts/+page.svelte#lowSample,
#anyProvisional). A figure with nothing behind it reads "–", never 0%.
Leader names the brand with the highest Visibility on the prompt among
you and the competitors you track and have not paused, values compared as
shown, to one decimal. You show as "You". A tie lists every tied brand: the
first two, then "+N", with all of them and their Visibility in the tooltip.
Leader reads "–" when the prompt has no analysed answer in the window or no
tracked brand is named in its answers. The column's tooltip says "Highest
Visibility among you and the competitors you track", because the prompt's
own Brands tab also ranks companies you do not track and can show one above
the leader here (api/services/prompt_metrics.py#_leaders, #_leader,
frontend/src/lib/prompt-figures.js#leaderLabel).
Select a figure's heading, or Leader's, to sort the list by it: best first
on the first click (the highest value, or the lowest for Pos.), worst first
on the second. A prompt with no value is last either way, and Leader sorts
by the leader's Visibility. The Prompt and Google demand sorts are
unchanged, and with no sort chosen the list keeps its order, newest prompt
first (frontend/src/lib/prompt-figures.js#sortByFigure,
api/routers/prompts.py#list_prompts).
The figure columns need a wide table, as on a 1440 or 1920 pixel window with the Analyst panel closed. In a narrower table the same five figures and the leader sit in a compact row under each prompt's chips, label over value with the change beside it, and the figure sorts are not offered there.
Paused prompts stay listed, and their figures cover whatever answers they have in the window, so a prompt paused before the window began reads "–" throughout. So does a prompt not checked against the engine chosen in the filter bar; its engine icons say which engines it runs on. When no prompt has an analysed answer in the window, a line above the table says so, as in "No analysed answers in the last 7 days, so every figure reads –.", followed, unless the window is already 90 days, by a link to the last 90 days.
The figures load in a request of their own and do not hold up the list:
the prompts show at once, with a grey bar in each figure until the figures
arrive, and the figure sorts are offered once they have. The request spends one query from the
project's Explorer query budget
and runs within the Explorer's 15-second limit
(api/services/explorer/query.py#explorer_batch). When it fails or runs
out of time, the list still shows every prompt, with "–" in every figure,
and one line above the table: "Figures could not be loaded. Try again in a
moment." (frontend/src/routes/(app)/prompts/+page.server.js#load).
Filters on the list
The filter bar's
tag, country, persona and language chips choose which prompts are listed:
a prompt is listed when it carries the tag and has an active target in the
chosen country, for the chosen persona and in the chosen language, each
checked on its own. A city target counts for its country, so choosing the
United Kingdom finds a prompt tracked only in London
(api/routers/prompts.py#list_prompts,
api/services/answer_filters.py#prompt_conditions). The same chips narrow
the figures to the answers that match them. The date range and engine chips
change only the figures: a list of prompts is not a set of answers, so they
never hide a prompt (frontend/src/lib/nav.js#filtersFor,
frontend/src/routes/(app)/prompts/+page.server.js#load). When the chips
leave no prompt, the page says "No prompts match these filters" and
Show every prompt clears the four that choose prompts, keeping the date
range and engine.
Six dropdowns sit above the table on every project: status, keyword, and
the four classification dimensions described below. Each one narrows what
is left rather than widening it, so a prompt has to satisfy every filter
you have set at once, the filter bar's included
(frontend/src/routes/(app)/prompts/+page.svelte#keywordFilter). They pick
prompts by the prompts' own attributes, so the figures on a row stay the
same. A City dropdown appears once some prompt on the list has a city
target; with a country chosen in the filter bar, it lists only that
country's cities. Choosing a city lists only the prompts tracked there and
narrows their figures to that city's answers, so a prompt tracked in Lyon
and across France shows its Lyon answers. The choice is part of the page's
address, so a link or a reload keeps it, and an address naming a city no
listed prompt targets reads as All cities
(frontend/src/routes/(app)/prompts/+page.svelte#cityChoice, #chooseCity,
#citiesShown, frontend/src/lib/prompt-figures.js#listedCity). The
keyword dropdown and the chips on each row both exist because the list
endpoint returns a prompt's keywords alongside its tags
(api/routers/prompts.py#list_prompts, api/schemas/prompt.py#keywords).
Each row carries a chip for every active audience currently tracking
that prompt, a chip for every real language it runs in (an As-written-only
prompt gets no language chip at all), and a chip naming its chosen engines
when it runs on a subset rather than every engine on your plan
(api/routers/prompts.py#list_prompts,
frontend/src/lib/languages.js#languageChips). See
Languages and templates for
what those language and engine values mean and how to bulk-apply a saved
combination.
Intent, buyer stage, theme and branding
Every prompt can carry four optional classifications, and each one is a
closed list rather than free text
(api/services/prompt_dimensions.py#VOCABULARIES):
- Intent, one of informational, navigational, commercial, comparison or troubleshooting: what the person asking is trying to do.
- Buyer stage, one of awareness, consideration or decision: how close they are to choosing.
- Theme, one of competitor alternative, pricing, use case, implementation, troubleshooting, regional opportunity, comparison or other: what the question is about.
- Branding, branded or unbranded: whether it explicitly names a tracked own or competitor brand, product or alias.
The API and database enforce the allowed classifications. The research agent
assigns the intent, buyer stage and theme vocabulary
(api/services/prompt_dimensions.py#check_constraint_sql). Branding is reviewed
separately through manual controls or the on-demand AI workflow below.
A prompt with no classification is normal, and it is not the same as a
prompt classified as "other". The fields are empty until something fills
them in. A prompt you accept from
Suggestions arrives
already classified, because the research that proposed it assigned all
three, and accepting it now carries them onto the tracked prompt
(api/services/prompt_discovery.py#accept_candidate). A prompt you type in
yourself can be classified in the add dialog. Imported prompts start unclassified;
use manual editing or request AI suggestions after import.
You can set the four yourself or review AI suggestions. The "Not classified" option in each dropdown puts one back to empty. That option is also a filter value, so you can list exactly the prompts nobody has labelled yet.
On the list, a classification is drawn as an outlined chip while a tag or a keyword is drawn as a filled one, because they are different kinds of thing: you choose a tag's name, whereas these four come from the fixed lists above. Hover a chip to see which dimension it belongs to, which matters because "comparison" and "troubleshooting" each appear in more than one of the four lists.
Not every prompt on the list has to start with you typing one in. Prompts → Suggestions is a queue of proposed prompts you track or dismiss, badge-counted on this same screen; that page covers where they come from.
Google demand
If Search Console is connected, each
prompt also carries a Google demand figure: the total impressions Google
recorded in the last 28 days for the search queries that prompt covers
(api/services/prompt_demand.py#demand_for_project).
Read that sentence literally, because the number is easy to over-read. It counts what people typed into Google, not what anyone asked an AI assistant. Nothing in the product measures how often a question is put to ChatGPT or Gemini, and this figure is not a stand-in for it. What it is good for is ranking your own prompts against each other: a question people already search for on Google is usually worth tracking before one nobody searches for anywhere.
A query counts toward a prompt when every meaningful word of the query
appears in the prompt. "bookkeeping software for freelancers" counts toward
"How much does bookkeeping software cost per month for a freelancer?",
because every word of the query is in there, with singular and plural treated
as the same word. It does not count toward "Which invoicing app is easiest
for a solo designer to use?", which shares none of it. The match runs in one
direction only, query into prompt, and a query has to contribute at least two
meaningful words, so a bare head term like "crm" never attaches itself to
every prompt you track (api/services/prompt_demand.py#query_matches_prompt).
Two prompts can cover the same query, and both then count its impressions. That is correct per prompt and wrong in aggregate: the column answers "how much Google demand does this prompt cover", so adding it down the list would count a shared query twice. There is no project total for exactly that reason.
The 1 to 5 score beside the impressions is relative to your own project,
not to any market. The prompt with the most impressions is a 5 and everything
else is placed against it on a logarithmic scale, so one very high-volume
prompt does not flatten the rest to 1
(api/services/prompt_demand.py#bucket_for). A 5 on a small project and a 5
on a large one are not comparable figures. Until at least three of your
prompts match a query there is no spread to rank against, so the impressions
appear without a score rather than with an invented one.
A prompt showing a dash matched no Google query. That is not the same as no demand: Google reports impressions for queries it saw, so no match means we found no query covering this prompt, which may simply mean your site does not rank for it yet. It is never rendered as a zero; see How to read any number here.
On the prompt list, the note under the table says "Google demand covers the last 28 days of Search Console, whatever the window.", because the filter bar's date range and engine apply to your figures there, not to Search Console.
The figure appears in three places: as a sortable column on the prompt list, as a section on the prompt's own page listing the matched queries and their individual impressions so the total can be checked, and on each row of Suggestions, where it sits beside the research score. Those two numbers answer different questions: the research score rates how much visibility we think tracking the suggestion would win you, while Google demand counts impressions. A suggestion can score well on one and show a dash on the other.
With no Search Console connection the column, the section and the tile are absent rather than empty, and the figure is not part of the Prompts export, which carries stored fields only.
Importing a list from CSV or Excel

Import file, beside Add prompt, takes a whole portfolio in one pass instead of
one prompt at a time. The file needs a column of prompt text; country and
tags columns are optional. Headers are matched by name, so prompt,
query or question are all recognised for the text column, and a file
whose headings we cannot place asks you to point at the right columns rather
than refusing it (api/services/prompt_import.py#detect_columns). Comma and
semicolon delimiters both work, which covers the CSVs Excel writes in
different locales. A file can carry up to 2,000 data rows and 4 MB.
Excel .xlsx files read only the first worksheet, even when it is hidden;
other worksheets are ignored. The preview names the worksheet being read.
The first row supplies the headers, with at most 100 columns and 2,000 rows
after the header. Formula cells and Excel error cells are rejected: replace
formulas with values before uploading. Password-protected workbooks, macros
and older .xls files are not supported. Workbooks that expand beyond 32 MB
are rejected. Excel then uses the same column mapping, validation, duplicate
handling, row selection and slot budget as CSV
(api/services/workbook_import.py#parse_xlsx).
A country cell takes ISO-2 codes or full country names, comma-separated, and each one has to be enabled for the project already: a country the project does not track is a row error naming it, not a silent skip. Tag names that do not exist yet are created during the import, matching existing tags without regard to case, which is what typing a new tag into the add-prompt form already does.
Choosing a file previews it and writes nothing
(api/routers/prompts.py#preview_prompt_import). The preview is a row-by-row
verdict: what each row would create, which countries are new, how many prompt
slots it would consume, and for anything unusable, the specific reason. Rows
that are fine remain importable while broken ones sit beside them with their
error, so a single bad country code does not send you back to fix the file
before importing any of it. Several rows naming the identical prompt are
merged into one prompt covering every country between them, which is why the
preview lists row numbers rather than one line per file row.
A row whose prompt text already exists in the project adds its new countries to that prompt. It does not touch that prompt's tags, which stay as you curated them in the app, and a row that asks for nothing the prompt is not already tracking reports "already tracked" and is skipped. Because a paused prompt is outside both the quota and the daily run, a country added under one stays paused and costs no slot until you resume it; the preview says so on that row.
Every new country costs one prompt slot, the same as adding one by hand, and the preview states how many of your plan's slots are left before you commit. The slot budget is reserved for the duration of the import, so two people importing at once cannot both spend the same last slot. An import that does not fit is refused whole rather than part-written.
Importing the same file twice is safe. A prompt is identified by the exact
text you imported and a country by the prompt it belongs to, both enforced in
the database, so the second run reports everything as already tracked and
creates nothing (api/routers/prompts.py#import_prompts). That also makes a
retry after a failed import the right move rather than a risk.
Inside one prompt
Opening one prompt answers three questions in order: are you in the answer, who is instead, and what to do about it. The header says what the prompt is and where it runs, each fact labelled: Where (its active countries and cities, with any inactive ones named underneath as excluded from future runs), Audience, Language (only once the prompt runs in a language rather than only as written), Engines ("All on your plan", or the engines you limited it to) and Last run. Its classification, tags and keywords follow, each group labelled.
The verdict and the Brands and Sources tabs count the same answers:
this prompt's completed runs in the
filter bar's
7, 28 or 90 days ending yesterday, keeping the latest valid result per
target, engine and day (api/services/execution_reads.py#daily_execution_filter).
The engine, country, persona and language filters narrow those answers;
there is no tag filter here, because one prompt either carries a tag or does not
(api/routers/pages.py#PROMPT_DETAIL_ACCEPTS). With no completed answer in
that window, or none matching the filters, there is nothing to show, not a
zero; see
How to read any number here.
Are you in the answer
A sentence leads the page: it says the result in words and names the companies the answers recommend most, with how many answers recommended them. It leaves the companies out when nobody was recommended, or when your own brand was recommended at least as often.
Two figures follow, each written as a count first so a small sample reads
as one. Cited is how many answers listed your domain among their
sources, out of all the answers: the prompt's
citation rate. Named is how many
answers named your brand, out of the answers whose brands have been
extracted (api/routers/pages.py#prompt_brands_page). The two can have
different denominators for a while after a run, while brand extraction
catches up, and the sentence says so when they do. Most recommended
repeats the leading companies beside them, when there are any.
By engine splits both figures per engine, one tile per engine, and each
tile's Latest answer opens that engine's newest completed run in the
window and filters (frontend/src/lib/prompt-answers.js#latestAnswerIds).
The tiles replaced the strongest and weakest engine cards and the engine
bars, which showed one fact three ways and picked an arbitrary "strongest"
engine whenever every engine was at zero.
What to do next
Three cards sit under the verdict. First, Your pages for this prompt: the page on your own site that should answer this prompt. Mapping one is what gap analysis compares against.
Then Gap analysis: findings that compare the pages AI engines cite for this prompt with yours and say what to change, each linking to its own page (see Optimizations). The findings open full width under the cards. Gap analysis reads the last 30 days across every engine and country, whatever the filter bar says. On Starter and above, company members and editors can Run gap analysis for this one prompt. It takes a few seconds, and when it finds nothing it says why:
- Fetching pages: the cited competitor pages are not saved yet. They are queued, so run it again in a few minutes.
- No difference found between your page and the cited ones.
- Already cited in at least 30% of answers, so the prompt is not a gap.
- No other site was cited, or no completed runs, in the last 30 days.
- Paused: gap analysis skips a paused prompt.
A run on one prompt does not count as the project's weekly run, so it never
delays the weekly topics or their notification
(api/services/citation_gap.py#find_gaps_for_project). Last, when the
answers recommend companies you do not track yet, a third card names them,
and Review in Brands opens the Brands tab.
The tabs
The rest of the page is five tabs: Brands, Sources, Runs,
Searches and, when a Google engine ran or Search Console has demand for
the prompt, Google. The open tab is part of the page's address, after
a #, so a link can open one, and switching tabs does not reload the page
(frontend/src/lib/prompt-answers.js#tabFromHash).
Brands and Sources show how many brands and sites they list, and Runs how
many runs; with no completed answer in the window, the page opens on Runs.
An old link to the tab under its former name, Competitors, opens Brands.
Brands answers who wins this prompt. It lists your brand, every
competitor you track (both shown even when no answer named them) and every
other company an answer named, ranked on this prompt alone: by Visibility,
then average position (lower first), then name. Brands with the same
Visibility and average position share a rank, and the next rank skips past
them, so two brands sharing first are followed by a third. A brand no answer
named has no rank and shows "–"
(api/services/prompt_answers.py#prompt_brands, #_assign_ranks). Each
row shows:
- Visibility: how many of the analysed answers named it, out of all
of them, with the percentage, as in "3 of 12 (25.0%)"
(
frontend/src/lib/prompt-answers.js#visibilityText). - Avg. position: its first position in each answer that named it, averaged over those answers, by the same rule as Overview's Pos.; 1 means every answer that named it named it first.
- Recommended and Cautioned: how many answers made it a top recommendation or a recommended option, and how many warned against it or did not recommend it, deliberately not counting answers that preferred a rival.
- Engines: which engines named it.
The first 15 rows show, with Show all for the rest. Your own row is
always in view: when it falls below the first 15, it is pinned under them
with its real rank (frontend/src/lib/prompt-answers.js#pinnedSelf).
Untracked names default to companies; Show products and technologies
adds the rest, including names the extractor could not classify. Those rows
have no rank, so hiding them leaves no rank missing from the default view
(frontend/src/lib/prompt-answers.js#visibleBrands). The tab lists at most
100 untracked names: the ranked companies in rank order, then the most named
of the rest. Ranks are worked out before that cut, so a rank never depends on
it, and when names are left out a line under the list says how many brands
are shown out of how many (api/services/prompt_answers.py#BRANDS_CAP).
One name in different capitalisation is one row, labelled with its most
frequent spelling. A brand you rejected as a suggested competitor on Settings →
Brands is still listed and ranked here: rejecting changes what is
suggested, not what is measured (see
Rejecting a suggestion).
Sources, by site, lists each cited domain with how many answers cited
it, its best position, the engines and up to three of its cited pages. A
tracked competitor's site carries its name, matched by domain, so a
competitor you track today labels its site on older answers too
(api/services/prompt_answers.py#cited_sites). By engine, it lists every
citation in the answers the numbers use, not every attempt, with its
position in the answer and the country it was asked from. Only your own
site is marked in colour.
Company members and editors can Track any untracked company or site from either tab. Tracking credits the answers that already named it; see Tracked versus untracked.
Runs opens with the Answer features card, then
lists the runs in the same window and filters, failed ones and runs where
Google showed no AI answer included. The list holds the 50 most recent; when
there are more it says so, as in "Showing the 50 most recent of 412 runs in
the last 28 days", and the tab's
count is every run in the window, not only the 50 listed
(api/routers/pages.py#RUN_HISTORY_LIMIT). Every attempt is retained,
including same-day reruns. The verdict and the counts above use only the
latest valid outcome per target, engine and day; a failed or running retry
does not hide the previous successful result
(api/services/execution_reads.py#daily_execution_filter). "Last run" in
the page header is the prompt's newest run of any kind, whatever the window
and filters. Only a completed run's citations are counted; any other run
reads a dash in the Citations column. Each run names its location ("GB ·
London" for a city target), and its expand button shows how that location
reached the engine, such as "Country sent natively and in the prompt; city
sent natively and in the prompt", or "Location delivery not recorded" for a
run from before that was stored
(frontend/src/lib/location-delivery.js#deliveryText). See
How location reaches each engine.
Completed runs have a View answer link. The run list itself carries no answer text; the link loads that one run's full answer on its own page: the prompt sent, the formatted response, and references labelled Web source, Shopping and Local business. Filter the references by type and inspect product, brand and merchant details where supplied. Shopping appearances stay separate from web citation counts. The same references appear on the admin execution page. See All references in a response.
Searches is what each engine searched for before answering (see
Fan-out). It shows each engine's newest
completed run inside the same window and filters, so with an engine chosen
only that engine appears (api/routers/pages.py#prompt_fan_outs). If those
searches cannot be loaded, the tab says so and offers Retry, rather than
reporting that the prompt has no completed run.
Google holds the Google results card and the prompt's Google demand.
Google results
Google AI Overviews and Google AI Mode add a Google results card to a prompt's page, on its Google tab, when either has runs in the window and filters. How both engines are collected, and why a run can show no AI answer, is on Engines and measurement.

The numbers in this screenshot are demo data: fixed fictional responses run through the product's own collection and detection code.
- Shown rate, per Google engine: "AI Overview shown on 12 of 20 runs
(60%)" or "AI Mode answered on 12 of 20 runs (60%)". A run counts when
it completed or when Google showed no AI answer; a failed run does not
(
api/services/google_serp_reads.py#answer_shown_by_engine). - Organic rank and AI Overview citations, for your site and then each
tracked competitor that is active: its average organic position over the
Google AI Overviews runs where it appears on the first page of Google's
results, on how many runs it appears there, and on how many of the
Overviews shown it was cited, as in "Your site: average position 4.5, on
the first page on 12 of 20 runs; cited in the Overview on 6 of 12
Overviews shown". Every AI Overviews run counts,
whether or not an Overview was shown, because the organic results are kept
either way. Your site is matched the way a citation is; a competitor is
matched by its domain against the competitors active now, so a competitor
added later is counted on older runs too
(
api/services/google_serp_reads.py#organic_panel). Only Google's first page of results is kept, usually 8 to 10 organic results; every result on it is in the Organic results export (see Exports). Google AI Mode has no organic results.
On the Runs tab, a run where Google showed no AI answer reads No AI
Overview shown or No AI Mode answer, with no citation count. Each
Google AI Overviews run lists your site's organic position and each
competitor that ranked or was cited, and whether the Overview cited it, or
that no Overview was shown, as in "Your site #3 · cited" or "Your site not
on the first page · not cited".
Each Google run's expand button also shows which language was sent:
"Language sent to Google: English"
(api/services/google_serp_reads.py#serp_language_label). A city target
whose city has no coordinates on record reads "city targeted, but sent to
Google at country level (no coordinates for this city)" there too.
When every Google run in the window showed no AI answer, the page says
"Google showed no AI answer on any Google run in the last 28 days" rather
than that there are no completed runs.
A variant that never runs on a Google engine is listed at the top of the
Runs tab's list, once per engine, with the reason: "Not run on Google AI
Mode: United States · Procurement lead · As written (personas are not sent
to Google)". The other reasons read "language not supported by AI Mode"
(or AI Overviews) and "prompt over 700 characters once encoded for Google"
(api/services/google_serp_reads.py#not_run_for_prompt,
api/services/collection.py#target_runs_on). The Add and Edit prompt
forms say the same in their preview, as in "Google AI Mode: 3 persona
variants not run", and the monthly estimate there leaves persona
and unsupported-language variants out (see
Languages and templates).
Answer features
An Answer features card opens the Runs tab: one row per
engine with a completed answer in the window and filters, one column per
feature (web search, shopping, local businesses, ads, video, images and
tables). Each cell is the share of that engine's checked answers where the
feature was present, with the count beneath, as in "40%" over "2 of 5"
(api/services/response_feature_reads.py#answer_features_by_engine).
A cell reads a dash when the engine does not report that feature, Not
recorded when the engine's searches were not recorded for those answers
or, on Gemini, when every answer was left out of shopping or local
businesses because its product or place links were listed for another
country, and Not checked when its answers have not been checked yet. A cell's
title also names any of the engine's answers from before it reported the
feature, such as Perplexity answers collected before Sonar; an engine
that reports nothing we can count, such as Google AI Mode, has one line
reading "Reports no features we can count"
(frontend/src/lib/answer-features.js#featureCell). Hover a column
heading to see which engines report it.
The run list has an In the answer column: a chip for each feature
present in that answer, in the same order, with a count for shopping, local
businesses, ads, images and tables ("Shopping 4", "Local businesses 16",
"Tables 2")
(frontend/src/lib/answer-features.js#featureChips). A completed answer
not checked yet reads "Not checked"; any other run, and a checked answer
with nothing present, reads a dash. How each feature is detected, and which
engine reports which, is on
Answer features.
ChatGPT runs
ChatGPT is collected through DataForSEO like the Google engines, so
some variants do not run on it either (see
What reaches ChatGPT). They
are listed at the top of the Runs tab's list the same way, as in "Not run on
ChatGPT: London, GB · General · As written (cities are not sent to
ChatGPT's app)". Each of the four reasons has its own wording
(frontend/src/lib/google-serp.js#skipReasonText):
- a persona variant: "personas are not sent to ChatGPT's app"
- a city variant: "cities are not sent to ChatGPT's app"
- a Chinese variant: "language not supported by ChatGPT"
- a prompt too long for it: "prompt over 2,000 characters once encoded for ChatGPT's app"
The list comes from the same rule the daily run uses
(api/services/google_serp_reads.py#not_run_for_prompt,
api/services/collection.py#target_runs_on), and the Add and Edit prompt
previews count the same skips, as in "ChatGPT: 2 city variants not
run". Each ChatGPT run's expand button shows which language was sent:
"Language sent to ChatGPT: English"
(api/services/google_serp_reads.py#serp_language_label). ChatGPT
always answers when a run succeeds, so it has no shown rate and is not part
of the Google results card.
Gemini runs
Gemini is collected through DataForSEO too, so some variants do not
run on it (see
What reaches Gemini).
They are listed at the top of the Runs tab's list the same way, as in "Not
run on Gemini: United States · Procurement lead · As written
(personas are not sent to Gemini's app)". Each of the three reasons has its
own wording (frontend/src/lib/google-serp.js#skipReasonText):
- a persona variant: "personas are not sent to Gemini's app"
- a Chinese variant: "language not supported by Gemini"
- a prompt too long for it: "prompt over 2,000 characters once encoded for Gemini's app"
City variants run on Gemini: the city's coordinates are sent, and
the run's Location line reads "Country sent natively; city sent natively". A
city with no coordinates on record runs at country level, and its Location
line reads "city targeted, but sent to Gemini's app at country level (no
coordinates for this city)"
(frontend/src/lib/location-delivery.js#deliveryText). A local question
tracked for a whole country is answered for wherever DataForSEO's
connection is, so track local prompts on Gemini as city targets.
The Add and Edit prompt previews count the same skips, as in "Gemini
(app): 3 persona variants not run". Each Gemini run's expand button
shows which language was sent, as in "Language sent to Gemini:
Portuguese (Brazil)"
(api/services/google_serp_reads.py#serp_language_label). Gemini
has no shown rate and is not part of the Google results card.
Organize a selection
Use the row checkboxes to select prompts, or the header checkbox to select all prompts matching the current filters. Organize selected lets you set or clear intent, buyer stage, theme and branding together. Each field starts at Leave unchanged. Tags can be added, removed, or replaced; replacing with no tags selected clears the selection's tags.
Selection survives filter changes. The toolbar names how many selected prompts are outside the current filters, and changes apply to the entire selection. Clear the selection before choosing a different group.
Pause selected stops future scheduled runs while preserving history and
country targets. Activate selected resumes those targets and checks the
company's available prompt slots for the whole selection. Bulk changes
are atomic: an invalid prompt, foreign tag, or insufficient quota rejects the
whole change. Company members and editors can make these changes; viewers cannot
(api/routers/prompts.py#bulk_update_prompts,
api/services/prompt_bulk.py#organize_prompts).
Prompt coverage
Before pausing prompts to free slots, open the Coverage tab on Prompts. It compares the last 28 days of answers to the prompts running now and recommends a set you could pause together while every source and brand those prompts see regularly is still seen by a prompt you keep. It never recommends a prompt other work depends on, or the last prompt measuring a country, city, persona, language or engine. You can preview any selection first, and company members and editors can pause it from there through the same bulk change as Pause selected; resuming works as described above. It is on every plan. See Prompt coverage.
Review AI classifications
Open the Classify tab on Prompts. Company members and editors of projects with the prompt-classification entitlement (standard Starter, Growth and Pro plans) can ask the configured model to suggest an intent, buying stage, theme and branding for existing prompts, including manually written or imported ones. This is on demand and uses normal model usage; saving or importing a prompt does not trigger a call. On other plans the tab says so and points to Tracked, where the same four can be set by hand or in bulk.
The tab opens on your tracked prompts with their current values in columns. A
summary counts the prompts still to classify (any of the four missing) and how
many carry each classification. The list groups prompts as Not
classified, Partly classified and Fully classified, in that order
(frontend/src/lib/prompt-classify.js#groupByStatus). Search, or filter by
status or theme, and tick the prompts you want; ticks survive filtering. A
group's checkbox adds its prompts until the batch is full. A batch holds
up to 25 prompts (frontend/src/lib/prompt-classify.js#toggleWithinLimit).
Suggest classifications, in the bar at the bottom, sends the batch. It can
take a minute or two: the model call gives up after 90 seconds
(api/services/prompt_classification.py#suggest).
Branded means explicitly naming a tracked own or competitor brand, product or alias. Unbranded means it does not; uncertain values remain unclassified. Manual labels and bulk editing remain available on every plan. Branding can also be edited manually, changed in bulk, filtered on the prompt list and downloaded in prompt exports. It does not classify historical answer content or add a sentiment filter.
The review shows each prompt with the model's short reason under it and a
dropdown per classification set to the suggested value. A value that differs
from the prompt's current one is outlined and says what it was. Prompts with a
suggested change come first and start ticked; prompts where the model agrees
with every current value come after, unticked
(frontend/src/lib/prompt-classify.js#reviewRows). Changing a dropdown ticks
its prompt (frontend/src/routes/(app)/prompts/classify/ClassifyReview.svelte#change).
Save updates all four fields of every ticked prompt together, so a value
the model left blank clears that classification on a prompt that had one: the
review counts that as a change and shows the old value, and you can set it back
before saving. An unticked prompt is unchanged. Discard returns to the list
with the same prompts still ticked
(frontend/src/routes/(app)/prompts/classify/+page.svelte#discard). The review
expires after 24 hours, can be applied once, and rejects changed prompts or
tracked-brand context. Request fresh suggestions if it becomes stale
(api/services/prompt_classification.py#apply_review).
Requests are limited to one batch per project per minute and 40,000 total prompt characters. Model errors change no prompts. Suggestions are advisory; review ambiguous brand names and do not treat the rationale as verified fact.


Related
- Personas: buyer audiences you can run a prompt as, how they use prompt slots, and what changes when they run
- Prompt suggestions: where suggested prompts come from
- Search plan: your Google searches and tracked prompts grouped into topics
- Prompt coverage: which running prompts you could pause while what they see regularly is still covered
- Fan-out: what each engine actually searched for behind this prompt, and the eight categories those searches fall into
- Answer features: the shopping, local businesses, ads, video, images, tables and web search each engine's answers held
- Key terms: what counts as a prompt, a mention, and a citation
- Your first scan: the daily run in full, and how long the first one takes
- Engines and measurement: which engines run, and what fan-out means
- Metrics defined: every project-wide number's exact formula and denominator
Last verified 2026-11-03