DEV Community: WEBVOGUE Technologies

I asked ChatGPT and Gemini 50 questions my buyers ask. My SaaS showed up once.

WEBVOGUE Technologies — Fri, 23 Oct 2026 11:58:12 +0000

My product was named in 1 of 50 AI answers. Its biggest competitor was named in 19.

These weren't vanity searches. They were 25 questions a real buyer types before they've heard of any brand, each asked on ChatGPT and on Gemini. Search Console doesn't show what ChatGPT or Gemini say about you, and a rank tracker can't either. So I measured it myself.

Here's what came back, what surprised me, and the code I use to turn a pile of AI answers into numbers you can track.

Disclosure: the product is DropPerch, a domain-expiry monitor I run, and I measured it with CiteGaps, which I also build. All the numbers below are from that one workspace, week of 12 October 2026.

The setup

25 buyer questions, written the way people search before they know any brand. For example: "What is the best domain expiry monitoring software for small businesses?"
No brand names in the questions. "Is DropPerch good?" tells you how an AI describes you, not whether it recommends you.
Two engines: ChatGPT and Gemini. Collected live, the way a buyer sees them, sources included. I didn't use the bare model API, because without web search it doesn't show what buyers see or which pages it cites.
One week, 50 answers. For each answer I kept the full text, every brand named, its position, and every cited URL.

The result

Brand	Share of the 50 answers that named it
DropCatch	38%
ExpiredDomains.net	36%
DomCop	32%
UptimeRobot	24%
Watchman Tower	20%
DropPerch (mine)	2%

One ChatGPT answer to that small-business question listed HetrixTools, UptimeRobot and DomainMOD. DropPerch wasn't in it.

Three things I didn't expect

1. I was cited more often than I was named

DropPerch was named in 2% of answers but linked as a source in 4%. So in at least one answer, the engine used my site as a source and still recommended someone else.

A mention (your brand in the text) and a citation (your URL in the sources) are different signals, and they move separately. Track both.

2. The most-cited source was a competitor's own website

The single most-cited source across the week was domcop.com: 102 citations in 50 answers. DomCop is also on the competitor list, named in 32% of answers.

That changed how I think about the problem. The engines get their shortlist from a handful of pages, and one of those pages is a competitor explaining the category in its own words. If my site and the pages around it don't answer the same questions as clearly, I'm not on the shortlist.

3. A forum thread was doing my competitors' marketing

One answer that named DropCatch, ExpiredDomains.net and DomCop, and not DropPerch, cited a discussion thread recommending DropCatch and ExpiredDomains.net. A thread an AI engine quotes is free marketing for whoever it names. A genuine, disclosed reply there can be worth more than another blog post on my own domain.

The code: turning answers into three numbers

Once you have the answers, you only need three numbers. Here's the scoring logic, simplified from what I run in production:

type Answer = {
  brands: { name: string; position: number }[]; // in the order the answer named them
  citedDomains: string[];                        // e.g. ["domcop.com", "reddit.com"]
};

function score(answers: Answer[], brand: string, domain: string) {
  const key = brand.toLowerCase();
  // Your position in each answer, or null when you weren't named.
  const positions = answers
    .map((a) => a.brands.find((b) => b.name.toLowerCase() === key)?.position ?? null)
    .filter((p): p is number => p !== null);

  const cites = (d: string) => d === domain || d.endsWith(`.${domain}`); // count subdomains too

  return {
    // How often you make the shortlist at all.
    visibilityShare: positions.length / answers.length,
    // How often the engine uses your own site as a source.
    citationShare: answers.filter((a) => a.citedDomains.some(cites)).length / answers.length,
    // Where you appear when you DO appear. Never average in the misses.
    avgPosition: positions.length ? positions.reduce((s, p) => s + p, 0) / positions.length : null,
  };
}

Run the same function for each competitor and you get the table above.

Getting brands out of free text is the fiddly part. I give each answer to an LLM with a strict JSON shape, {"brands":[{"name": string, "sentiment": "positive"|"neutral"|"negative"|"mixed"}]}, and take each brand's position from the order it returns. Sentiment comes for free, and it matters: being named often but described badly is its own problem.

Rules that keep the numbers honest

Keep the question set fixed week to week. Change the questions and you've changed the measurement.
Exclude failed answers instead of counting them as "not named".
Mind the sample size. With 50 answers, one answer is 2 percentage points. A 3-point jump can be noise.
Read the trend, not the week. AI answers change from one session to the next. One week is a sample, not a verdict.

Bonus: see ChatGPT's clicks in your analytics

When ChatGPT links to a page, it adds utm_source=chatgpt.com to the URL. That's from OpenAI's publisher FAQ. In GA4, look under Reports → Acquisition → Traffic acquisition for chatgpt.com as a source. If your visibility share rises but those visits don't, the answers mention you without linking to you.

What I'm doing about it

Nothing clever. Just the list the data gave me:

Get onto the third-party pages the engines already cite: the directories, comparison lists and threads in the sources, before any new content of my own.
Answer the exact questions I'm missing. A page per lost question, with the specifics a buyer needs, not a generic "features" page.
A comparison page against the brand at 38%, because a buyer comparing tools asks exactly that question.
Reply, with disclosure, in the threads that get cited.
Re-run the same 50 answers every week and watch the trend.

I'll post the follow-up when there's a trend worth showing, good or bad.

Try it on your own product

You can do all of this by hand with a spreadsheet: write 25 buyer questions, ask each one in a fresh chat, and log who's named and what's cited. Reading 50 answers a week gets old fast, which is why I automated it.

If you want a quick look first, there's a free check: one question, live answers from ChatGPT and Gemini, no sign-up. I also wrote up what each of these metrics means and how to read them together.

Have you checked what ChatGPT says when someone asks for a tool like yours? I'm curious whether anyone else is getting cited without being named. Tell me in the comments.

What I learned checking 65 client domains with RDAP instead of WHOIS

WEBVOGUE Technologies — Sat, 12 Sep 2026 15:17:20 +0000

I built a domain expiry monitor, and to test it against something other than my own domains I pointed it at the "our work" pages of 30 US web design agencies — the client sites they link to publicly — and checked every domain against its registry.

The results were mildly alarming, but the interesting part was everything that went wrong on the way there.

The results first

65 client domains across 14 agencies:

1 had already expired, 60 days earlier
3 were inside 45 days, the nearest with 3 days left
the rest ran from 46 days to several years out, clustering at 3–6 months

I'm not naming the agencies or the domains. Telling someone privately that their client's domain is about to lapse is useful; publishing it is exposing somebody's client.

Why RDAP and not WHOIS

WHOIS returns free text in roughly as many formats as there are registrars. RDAP (RFC 7482/9083) returns JSON, over HTTPS, with a documented shape.

The single nicest property: a 404 is an answer. In RDAP it means "this domain is not registered", which is precisely the event worth alerting on. No string matching on "No match for domain".

const res = await fetch(`${base}domain/${name}`, {
  headers: { Accept: 'application/rdap+json' },
})
if (res.status === 404) return { registered: false }

Three things that will bite you

1. The registrar's name is hidden in a jCard

There's no registrar field. The registrar is an entity with the registrar role, and its human-readable name lives inside a vCard-in-JSON structure:

const entity = (body.entities || []).find((e) => (e.roles || []).includes('registrar'))
const card = entity?.vcardArray?.[1] || []
const fn = card.find((f) => Array.isArray(f) && f[0] === 'fn')
const name = fn?.[3] ?? null   // "GoDaddy.com, LLC"

vcardArray[1] is an array of ["fn", {}, "text", "GoDaddy.com, LLC"] triples. That awkwardness is why so many tools show you IANA registrar ID 146 instead of a name — and "where do I renew this" is the actual operational question for anyone holding domains across several registrars.

2. IANA's bootstrap does not cover every TLD

The bootstrap file maps TLDs to RDAP servers, and .de, .co and .gg simply aren't in it. There's no authoritative endpoint to ask.

The right response is to say so. "The registry publishes no expiry date" is a fact about the registry, not about the domain, and it's more useful to a user than a number you inferred from somewhere else. Any tool that confidently shows an expiry date for a .de is guessing.

3. Public suffixes

cartwright.co.uk naively reduces to co.uk. Query that and you get the registry's own record, then cheerfully report the registry's expiry date as your user's domain expiry. The full Public Suffix List is thousands of entries; even a small hardcoded set of co.uk, com.au, co.nz and friends prevents the embarrassing version of this bug.

The bug that nearly discredited the whole thing

My first extractor took every href on the page. For one agency it confidently reported licdn.com, hotjar.com, addtoany.com and gmpg.org as their clients.

All four came from the <head>: <link rel="preconnect"> hints and the XFN profile link WordPress writes into every page.

I started adding them to a blocklist, then stopped — every new analytics vendor adds another entry, and the blocklist can never be finished. The structural rule can:

// Only anchors. A person clicks anchors, and only anchors point at clients.
const re = /<a\b[^>]*?\bhref\s*=\s*("([^"]*)"|'([^']*)'|([^\s">]+))/gi

One line, and the entire category of failure disappears.

A related one: an agency's second domain isn't the agency's client. One firm's site was at atendesigngroup.com and they also owned aten.io; another at openmediafoundation.org owned open.media. Matching only the exact domain you crawled isn't enough — comparing the leading label catches both.

About a third of sites hard-block automated requests

This one changed the architecture. I wrote the fetcher with fetch, and got 403 on every single site, including with a complete set of genuine browser headers. Not a Cloudflare JS challenge you can wait out — a flat 403, identical in headless Chrome and in a real headed one. It's blocking by IP reputation.

I switched to driving a real browser, which fixed it for about two thirds of sites. That turned out to matter for a second reason I hadn't considered: most agency portfolios render their client grid client-side, in Webflow or React. Even a successful fetch would have returned markup with no client links in it, and I'd have spent a day blaming my extractor.

The unglamorous finding

Only 14 of 30 agency sites linked three or more client domains at all. The rest show client work as screenshots with no anchor.

That's a lot of backlinks being left on the floor.

If you want to look at what I built with this, it's at dropperch.com — free tier monitors domains. But the RDAP notes above are the genuinely reusable part, and they're yours whether or not you ever look at it.