AI Visibility Tools Charge $399 a Month for Three API Calls. Here's the Prompt to Build Your Own.

In February 2026, a company called Profound raised $96 million at a $1 billion valuation. Lightspeed led the round. Sequoia and Kleiner Perkins came along. That put them at $154.5 million raised in roughly eighteen months, which is one of the fastest funding runs enterprise martech has ever produced. They serve over 700 enterprises and more than 10% of the Fortune 500. Target, Figma, Walmart, Ramp, MongoDB.

The product asks ChatGPT a list of questions and counts how often your brand name appears in the answer.

I'm not being snide about it. That is genuinely the shape of the thing, and I know because I built the same product into the client dashboard I run. Three API calls, some string matching, a couple of charts. It runs for less than the price of a sandwich per month and I give it to clients for free.

There is exactly one thing the expensive tools do that mine does not, and it is not a small thing. I'll get to it, because if I skip it this post is just another GEO snake oil rant, and I'd rather be useful than smug.

What an AI Visibility Tool Actually Does

Strip the marketing off and there are four layers.

Poll. For every query you care about, ask each AI platform the question a real customer would type. Detect. Search the answer text for your brand name and your competitors' names. Aggregate. Count how often you showed up, split by platform and query, compared to last period. Render. Some KPIs, a share of voice breakdown, a table of recent polls you can click into.

That's the product. All of it.

In my dashboard that's poll.service.ts, detector.ts, aggregate.service.ts, and one small file per platform in a providers/ folder. About 1,600 lines of TypeScript for the backend, another 1,100 for the UI. It wasn't an hour of work, it was a weekend plus a few evenings, and most of that time went somewhere you would not guess.

The Whole Thing Is Three API Calls

Here are the three, with the actual model IDs, because vague architecture diagrams help nobody.

ChatGPT is gpt-4o-mini-search-preview through the Chat Completions API. One gotcha cost me an evening: the *-search-preview variants do not support OpenAI's Responses API, which is the default route for openai('model-id') in @ai-sdk/openai v4. You have to force the chat route with openai.chat(MODEL_ID) or it just fails. There's no native citation field either, so you pull URLs out of the response text with a regex and strip the trailing punctuation.

Perplexity is the model sonar at https://api.perplexity.ai/chat/completions. It's an OpenAI-compatible endpoint, and it hands you native citations as a citations[] array of URLs. Cleanest of the three by a wide margin.

Google AI Overview has no API at all, so you scrape it through SerpAPI's Google engine and read the ai_overview block. The gotcha here is subtler and it matters: Google only renders an AI Overview for certain query intents, mostly informational questions rather than local navigation ones. When the block is missing that is not an error. Nothing was shown, so your brand wasn't mentioned, which is a perfectly valid data point. Record it as an error instead and your dashboard starts reporting failures that never happened.

Each provider is a 60 to 140 line file behind a shared interface: a platform name, an isAvailable() check for the API key, and a poll(query, language) function. That's the extent of the integration work.

What It Actually Costs to Run

Let's do real arithmetic instead of vibes. Twenty tracked queries, three attempts each, two platforms, running weekly. That's 480 polls a month.

Line item	Calculation	Cost
OpenAI web search fee	240 calls at $25 per 1,000	$6.00
OpenAI output tokens	~192k at $0.60 per 1M	$0.12
Perplexity search fee	240 requests at $5 per 1,000	$1.20
Perplexity output tokens	~192k at $2.50 per 1M	$0.48
SerpAPI	240 searches, free tier covers 250	$0.00
Total		~$7.80

One honest caveat: that number is arithmetic on published list prices, not a screenshot of my invoice. I haven't sat down and reconciled it against my actual OpenAI and Perplexity bills. Treat it as the right order of magnitude, not gospel.

Now the other column. Profound Starter is $99 a month billed yearly and gives you ChatGPT only, 50 prompts, one seat. Growth is $399 a month for three engines, 100 prompts, three seats. Enterprise is custom, up to nine platforms. Peec AI sits around 89 euros a month. Otterly runs $29 to $489 depending on tier.

Notice which line dominates. OpenAI's $25 per 1,000 search calls is about 80% of my total and nothing else comes close. So the lever that controls your spend is attempts per query times how often you run it, not which framework you picked. Double the polling frequency, double the bill. That's the entire cost model.

Same pattern I keep hitting with everything I self-host instead of subscribing to. The compute is cheap. The interface around it is what gets priced.

The Part That's Actually Hard (And It's Not the API Calls)

Every difficult thing in this project lives in one file, detector.ts, and none of it is HTTP.

Start with the naive version: does the response text contain my brand name? Now watch it break.

The model writes your name with an umlaut it invented, or a diacritic that renders identically but isn't the same codepoint. Miss. So you normalize with NFKD and strip combining marks first, and suddenly accented spellings match.

Then you check for a client called Apple and your matcher happily finds them inside the word "Pineapple". You need word boundary checks, and \b in JavaScript is not Unicode aware, so you inspect the characters on either side of the match yourself.

Then you track a brand called "Wunderland Media" and every hit fires twice, once for the full phrase and once for "Wunderland" sitting inside it. Fix: sort your terms longest first and mark matched character ranges as covered so a shorter term can't re-fire inside a longer one.

Then there's the thing that makes this whole category slippery. LLMs don't answer the same question the same way twice. A single poll is noise dressed up as a data point. My runner does three attempts per query per platform and the result is a mention rate, a fraction, never a yes or no. If a tool shows you a green checkmark that says "you are visible", ask how many times they asked.

Two smaller lessons that cost me real debugging time. Never let a provider error abort the run: catch it, write a row with the error message, keep going. And persist results per query rather than one batch at the end, so partial results survive if the process dies halfway through.

None of this is hard in the sense of requiring a PhD. It's hard in the sense that you will get it wrong first, and your dashboard will confidently report numbers that are false while looking completely fine.

The Prompt: Build Your Own Tonight

Make a folder. Open it in VS Code or Cursor. Run claude. Paste this. It asks you one question about which stack you want, then builds the thing. You supply API keys and you're done.

I've had good results letting Claude Code work through a spec like this in one pass, the same way I let it rebuild a whole weekend project. The trick isn't cleverness, it's being specific about the parts that break.

Build me a self-hosted AI visibility tracker.

What it does: for a list of queries I care about, it asks several AI platforms
the question, checks whether my brand and my competitors get mentioned in the
answer, stores every result, and shows me the trend over time.

Before you write any code, ask me one question: which stack do I want. Offer
Python + SQLite + a simple web UI, Next.js + SQLite/Postgres, or Vite + React
with a small Node backend. Pick sensible defaults for everything else and do
not ask me anything further.

Config I provide in a .env file:
- OPENAI_API_KEY (required)
- PERPLEXITY_API_KEY (optional)
- SERPAPI_KEY (optional, for Google AI Overview)
Skip any platform whose key is missing instead of crashing. Log which
platforms you skipped.

Config I provide in a config file: my brand terms (a list of strings,
including common misspellings), my competitor names (a list of strings), and
my tracked queries (each with the query text and a language code).

Providers, one module each behind a shared interface with platform,
isAvailable() and poll(query, language):

1. ChatGPT: model gpt-4o-mini-search-preview via the Chat Completions API.
   The *-search-preview models do not support the Responses API, so make sure
   you use the chat completions route. There is no native citation field, so
   extract URLs from the response text with a regex and strip trailing
   punctuation.
2. Perplexity: model sonar at https://api.perplexity.ai/chat/completions,
   OpenAI-compatible. Read native citations from the citations array.
3. Google AI Overview: SerpAPI, engine=google, read the ai_overview block. If
   ai_overview is absent, record an empty response WITHOUT an error, because
   Google simply did not show an overview for that query. That is a valid data
   point, not a failure.

System prompt for each provider: answer the user's question directly and
helpfully the way this platform normally would, name specific companies,
products or services where appropriate, cite sources with URLs, and respond in
the requested language.

Polling: for each tracked query, for each available platform, poll 3 times.
LLMs are not deterministic, so one poll is noise. Never let a provider error
abort the run: catch it, store a row with the error message, and keep going.
Persist results per query rather than one batch at the end so partial results
survive an interrupted run.

Detection, and this is the part to get right:
- Case-insensitive.
- Normalize with NFKD and strip combining marks so an accented spelling still
  matches.
- Collapse whitespace so multi-word terms match as phrases.
- Respect word boundaries with Unicode-aware checks so "Apple" does not match
  inside "Pineapple". Do not just use \b.
- Sort terms longest-first and mark matched character ranges as covered so
  "Acme Digital" does not also produce a separate hit for "Acme".
- For every hit, store the term, the character offset, and a ~60-character
  context snippet on each side so I can audit it.

Storage: one row per poll with query text, language, platform, model name,
timestamp, brand_found boolean, brand mentions as JSON, competitor mentions as
JSON, cited URLs as JSON, the full response text, token count, and error
message. Give every run a shared run id.

Dashboard: overall brand mention rate for the period with the change versus the
previous period, a per-platform breakdown, a per-query breakdown sorted
worst-first, competitor share of voice, and a table of recent polls where I can
click through to the raw response text. Mention rate is brand_found divided by
total polls, expressed as a percentage.

Also give me: a single command to run a poll cycle, a README with setup steps
and an honest note on what each API call costs at current list prices, and a
scheduler example (cron or equivalent) for a weekly run.

Do not add authentication, multi-tenancy, billing, or a landing page. This is a
tool for one person tracking their own brand.

That's the whole thing. If you want to build your own AI visibility tracker, that prompt plus three API keys is the entire barrier to entry.

Here's Where I Have to Be Honest: My Tool Is Wrong Too

Surfer SEO ran 1,000 prompt executions per scenario comparing what the APIs return against what the actual ChatGPT and Perplexity interfaces show real people. The results are bad for everyone who measures visibility through an API, and that includes me.

ChatGPT API answers averaged 406 words. The scraped interface averaged 743. Around 25% of API responses returned no sources at all, while the scraped answers always did. Roughly 23% of API responses never triggered a web search in the first place. Brand detection failed in about 8% of API results and in none of the scraped ones.

Then the two numbers that actually hurt. Brand overlap between the two methods: 24%. Source overlap: 4%.

Perplexity is better but not fine. API answers averaged 332 words versus 433 scraped, returned about 7 sources versus 10, with 8% source overlap.

Their data scientist put it bluntly: "These differences are so explicit that monitoring responses from API as a proxy for your AI visibility is totally wrong."

He's right, and he's describing my dashboard.

The reason is structural. The API is the raw model. ChatGPT the product wraps that model in its own system prompt, its own retrieval, memory, and a pile of interface logic. Same model ID, different animal. I've written before about what ChatGPT actually searches for behind the scenes, and this is the same gap showing up from the other direction.

So what is the $399 actually buying? Scraping infrastructure against the real product interfaces, at scale, maintained against constant UI changes. That's genuinely hard, genuinely expensive to keep running, and it's the part I did not build. If somebody tells you the whole category is a scam, they haven't read this study either.

So Should You Build It or Buy It?

Build it if you're solo or a small agency, tracking one brand or a handful, you want a directional trend line rather than a defensible measurement, and you already run something you can drop it into.

Buy it if you need numbers that match what customers actually see in the product UI, you need historical baselines and cross-industry benchmarks you can't generate yourself, you want referral analytics wired into your logs or CDN, or you're reporting to a board that will eventually ask who audits this number.

Here's the middle path I'd actually suggest. Build it first. Run it for a quarter. Then find out whether anybody in your company ever acts on the number.

Most people check it twice and stop. That's a much cheaper thing to learn for eight dollars than for $4,788 a year.

What I'd Actually Do With the Number

Tracking is diagnosis, not treatment. A mention rate tells you that you're invisible. It does not tell you why, and it definitely doesn't fix it.

My dashboard has a second half that does more work than the charts do. It crawls the client page and the competitor page that's getting cited instead, then produces a structured comparison: topics the competitor covers that the client doesn't, structural signals models seem to prefer (FAQ blocks, schema markup, testimonials, clearly named services, team bios, transparent pricing), and services the competitor visibly offers. That output is the actual work list. The visibility percentage is just the thing that tells you to go look.

If you want the strategy side rather than the plumbing, I've written up what a 1.4 million prompt study found about getting cited by ChatGPT and how to control what AI says about your brand. Those are the parts that move the number.

Which points at what bothers me about this whole category. The tool is the cheap part. The fixes are the expensive part. And the industry is currently selling it in exactly the opposite order.

I run this for my clients as part of the dashboard they already have, because charging separately for three API calls felt strange. If you'd rather have someone do the expensive half, that's the conversation to have.