Query Explorer for AI SEO

An LLM query is the question a user asks an AI system like ChatGPT, Gemini, or Perplexity. Also called the prompt. But internally, that single question often is broken down into multiple smaller queries; especially if a web search is required to answer it.

That internal process is what QueryCat.app helps you see.

Firstly, people tend to write short (sometimes even single word) query on Google, but on LLMs, they tend to ask long queries in proper question format. Then, a Google query usually stays as-is when responding. An LLM query rarely does.

Instead, LLMs reinterpret, expand, and reformulate your question before answering it. That’s why two users asking “the same thing” may trigger different searches.

Fanout queries are the sub-queries that an LLM generates internally to answer a question properly. Because one long, multi-question query is often vague, incomplete, or ambiguous for LLMs to answer.

Think of them as: “If I had to answer this well, what else would I need to know?”

They’re not guesses. They’re like different angles to the same question.

LLMs do not always web search or cite sources. By default, they try to answer a query from their in-memory/training data.

However, they tend to make web searches when the model isn’t confident in its training data and:
• the topic is recent
• accuracy matters
• multiple viewpoints exist

Different LLMs make their web search differently. However, broadly they follow these steps:
1. The LLM interprets the query to see if it requires a web search. If not, they simply answer from memory, else, they go to step 2.
2. It generates fan-out queries
3. It performs targeted web searches
4. It selects and cites sources
5. It synthesizes an answer

Then this synthesized answer is presented to the user along with the links to cited sources.

Because they are tuned differently. Which is totally a decision of the LLM providers.

Broadly we can assume that they answer the same query differently because they:
• interpret intent differently
• generate different fan-out queries
• search different sources
• apply different citation thresholds

In fact, if you ask a query to one LLM twice, it’ll not only frame/write the answer differently, but also cite different sources.

That’s why QueryCat.app compares ChatGPT, Gemini, and Perplexity side by side to paint a bigger picture to explore LLM Query in detail.

No. Not always. And, for AI SEO, it helps to know when and what query does NOT trigger LLMs to cite sources when answering as much as knowing otherwise.

Because, if it’s not citing, it’s answering from memory, and there is little to none that you can do to get brand mention. It’s only when they cite, that there’s an opportunity to be mentioned.

So, know the difference and focus on the one that can yield. And this is a feature of QueryCat.app.

Not very much. All LLM providers are constantly updating the memory of their models—both old and new.

So, you might experience variable behavior regarding LLM query over time.

Yes — but indirectly, and that distinction matters.

Understanding LLM queries helps you see how a model interprets intent, how it breaks a question down, and when it decides to search the web instead of relying on memory.

That insight can guide how you think about topics, coverage, and supporting content — without pretending there’s a guaranteed outcome.

Honestly, not all. It differs for different LLMs. It even differs in what’s observable on chat UI and with the API of an LLM.

As of Dec ‘25, with ChatGPT and Perplexity API, you can observe:
• whether an LLM triggered web search
• which URLs it cited and their page title

In the case of Gemini API, you get fanout_queries upfront.

You CANNOT observe:
• internal model weights
• ranking formulas
• or how the same query might behave tomorrow

QueryCat.app is explicit about this boundary. It shows what’s observable, infers fanout_queries (reliably with SEO best practices), Source Diversity (with a simple heuristic), and calculates its own Citation Signal (which is based on the cited sources' count, diversity and distribution).

Most importantly, it chooses to stay quiet about what isn’t observable.

QueryCat.app runs real queries through real LLMs (their respective APIs, not chat interfaces) and captures what they show.

That includes: whether a web search was triggered, and what title + URL pair were referred to answer the query.

From that, it infers fanout_queries (for ChatGPT and Perplexity; Gemini provides it up front), Source Diversity (with a simple heuristic), and calculates its own Citation Signal (formula in QueryCat.app tab of FAQ).

In Single Query, you explore one query in detail.
In Bulk Queries, you compare multiple queries side by side to spot patterns.

No simulations. No synthetic prompts. Just live observable behavior.

QueryCat.app is a LLM Query Explorer.

It helps you see how large language models like ChatGPT, Gemini, and Perplexity actually answer a query — including when they search the web, what they search for, and which sources they cite.

Think of it as an AI SEO tool or instrument to look under the hood of LLMs.

Out tagline is both a statement to our users and a reminder to ourselves: understand AI SEO first, optimize later.

A lot of AI SEO today feels like astrology — bold predictions, vague scores, and confident claims without showing the underlying evidence. Astronomy, on the other hand, is about observation. You don’t predict stars by vibes; you study their movement with instruments.

QueryCat.app follows the same philosophy. Instead of guessing outcomes, it shows how LLMs actually search, expand queries, and cite sources. No prophecy — just observation.

Most AI SEO tools try to guess visibility or predict performance. QueryCat.app takes a simpler route: show what’s happening instead of forecasting what might happen.

If you’re trying to understand:
• why some sources get cited
• when LLMs trigger web search
• how query interpretation changes across models

…QueryCat.app gives you direct evidence.

By design, QueryCat.app does not:
• predict brand rankings on LLMs
• track prompts
• lists prompt volume
• estimate LLM traffic
• guarantee citations
• recommend optimizations

Those things require assumptions. QueryCat sticks to evidence. Like an astromer would.

QueryCat.app runs real queries through real LLM APIs — not the chat interface — and captures what the models actually expose during the process.

Specifically, it looks at:
• whether a web search was triggered
• which title + URL pairs were referenced to answer the query

From there:
• For Gemini, fan-out queries are often provided directly by the model.
• For ChatGPT and Perplexity, fan-out queries are inferred based on the titles and URLs the model cited while answering.

Source Diversity is then calculated by grouping those cited URLs into broad categories (for example: blogs, news sites, brand pages, reference sources) using a simple heuristic.

Citation Signal is a directional metric, not a prediction. It’s derived from observable LLM behavior, such as:
• how many unique sources were cited
• how diverse those sources were
• whether citations were dominated by a single source type

Here’s the exact logic used in the current version:

// Base score from source diversity
let score = Math.min(uniqueUrls.length * 15, 60);

// Bonus for multiple source categories
if (categories.size >= 3) score += 20;
else if (categories.size >= 2) score += 10;

// Penalty for single-category dominance
const maxCategoryCount = Math.max(...Object.values(categoryCounts));
if (maxCategoryCount / uniqueUrls.length > 0.7) score -= 10;

// Cap at 100
score = Math.min(score, 100);

The idea is simple: Out of two queries, the one that triggers more citations, from more varied sources, they are more likely to cite from multiple (and plausible different) sources another time.

No. And it’s important to say that clearly: Citation Signal is exactly what the name says—a signal, not a promise.

A few important clarifications:
• Citation Signal (CS) does not measure probability of being cited.
• A 100 CS does not guarantee a content on this topic will be cited.
• It’s meant for comparison and pattern spotting, not forecasting.

In short: it’s a signal you can observe and reason with — not a promise to rely on.

Right now, QueryCat.app supports three models:
• ChatGPT - gpt-4.1-mini
• Gemini - 2.5 Flash
• Perplexity - Search tool_call that powers all their models

Each model is analyzed separately via its API (not chat interface), so you can see where they behave similarly — and where they don’t.

Single Query is for deep dives into one query.
Bulk Queries does the same but for 2-5 queries in-a-go.

The logic, and the models behind them both are the same. Just different use cases.

Anybody interested in building AI SEO (or GEO or AEO) strategy based on real, irrefutable data should use QueryCat.app. That includes SEO freelancers, startup marketers, content strategists and even agencies exploring AI SEO or GEO.

Not really. It’s designed as an intuitive, simple webapp.

If you understand how people ask questions and why sources matter, you are good to go.

Free, No limits — as of Dec ‘25, in its beta version.

But it costs us for every hit across the three LLMs. Still, we plan to keep it like this for a month or so. During this period we shall gather feedback, refine the product – both the backend and frontend. So, kindly share and spread the word 🙏

Once we understand its demand and usage pattern, we plan to cap the daily limits and introduce paid plan.

But rest assured, it won’t be in like ~$200/month/seat deal. Cheaper by 1/10th or so because we aim to empower startups and freelancers looking for an affordable and reliable tool for AI SEO strategy.

The goal is to keep it honest, useful, and cheap — not locked behind enterprise pricing.

No. Queries are processed to generate results, then discarded. QueryCat.app does not build a database of user searches.

Later, when we introduce a paid option, we shall let users store data on their end.

However, we do encourage users to share non-sensitive query screenshot, csv and experience to improve our product.

More models, better comparisons, and deeper query-level insights are on the roadmap.

However the underlying pillar will remain the same: honest, useful and cheap.

Firstly, you came all this way, so thanks for your interest: If you have feedback, a feature idea, or want to collaborate, you’re welcome to reach out.

Email: mayankbishwas@gmail.com
Linkedin: @mayankbishwas