Skip to content
AeoNut

Free Open-Source and Self-Hosted AI Visibility Trackers: Worth It?

Is a self-hosted AI visibility tracker worth your time? Compare setup, upkeep, data control and engine coverage with a managed free plan before you decide.

Avinash Saurabh · · 15 min read

Two stacked cards, a server rack and a mint dashboard with a line chart, flank the words Self-Hosted or Managed?

For most freelance consultants tracking one client, a managed free plan is the better use of your time than an open source AI visibility tracker you run yourself. The DIY route is worth it when you need control over the code or the storage, and you already have the skills to run and secure the services behind it. That's the short version, and the rest of this piece shows you how to check which side you're on.

The reason this question comes up is simple. A client asks whether they show up in ChatGPT, you don't want a tool bill before they've paid you anything, and a search for free LLM brand tracking GitHub projects turns up real projects with real code, and phrases like self hosted LLM tracking make it sound like a weekend job. AeoNut's Free plan is one managed answer to the same problem: it's free forever for one client project, with unlimited prompts and every feature, and you bring your own keys. The platform costs nothing, and the AI answer data is billed by your own provider at its price.

This piece compares the two routes on setup, maintenance, data control and engine coverage. It doesn't walk through installing any one project, and it doesn't work out provider costs, which is a separate topic.

What counts as open-source, self-hosted and managed

These three terms get mixed up, and the mix-up is where a lot of bad decisions start, so it helps to split them first.

An open-source tracker is software whose license lets you use, inspect, modify and share it, and the Open Source Definition asks for more than readable source code. A public GitHub repository is not the same thing. GitHub's own licensing guidance says that without a license, a public repository is still covered by default copyright, and while others can view and fork it under GitHub's terms, that doesn't give them general permission to copy, distribute or build on it. So the first thing to check on any project is the license file.

A self-hosted tracker is one you run and operate yourself, with your own storage. Open source and self-hosted overlap, but they aren't the same. Software can be open source and still only run as someone else's service, and a self-hosted setup can still send some data to outside services.

A managed free plan is a tracker the vendor runs, with no platform fee. The things to confirm are whether it keeps tracking over time or gives you one check, what is capped, which engines it covers, and whether "free" leaves out the data provider's charges. Which kind of free offer fits you goes deeper on plans, trials and checkers, and AEO, GEO and LLM tracking tools sorts out which vendor label means which.

Also keep in mind that "no subscription" is not "no cost". A repository may cost nothing to download, but hosting, upkeep and the services it calls can still cost you something. This piece doesn't put numbers on those.

What you compareSelf-hosted open-source trackerManaged free plan
Who runs itYouThe vendor
SetupDepends on the project, from one app to several servicesSign up and add prompts
UpkeepUpdates, storage, uptime and fixes are yoursThe vendor's job
Data controlYou choose where it lives, but you have to check the data flowsYou rely on the vendor's terms
EnginesWhatever the project has actually builtWhatever the plan lists
Client reportsVaries a lot by projectCheck what the plan includes

Setup effort and upkeep

The setup effort changes a lot from one project to the next, and the fair way to judge it is by what the project asks you to run, not by how short the README looks.

OneGlanse is a good example of the heavy end. It's MIT-licensed and it collects answers by running prompts through the real websites for ChatGPT, Perplexity, Gemini, Claude and Google AI Overview. To schedule runs you self-host it, and its VPS guide describes an app, an agent worker, PostgreSQL, ClickHouse and Redis. It asks for at least 2 vCPU, 4 GB of RAM and 40 GB of SSD, and recommends 4 vCPU, 8 GB and 80 GB. It also calls for a proxy that works with provider sites, because datacenter IPs may get blocked, and you capture each provider login in a real local browser and then move the saved session to the server, where it can expire. The guide also warns that ClickHouse data grows and can fill the disk.

None of that is a flaw in the project. It's what it costs to read the same pages a person reads. But it means the project comes with a job attached, and that job is yours.

At the lighter end is Prompt Clarity, which is AGPL-3.0 and built on Next.js with SQLite. It collects through API integrations with OpenAI, Claude, Gemini, Perplexity and Grok, and it schedules runs with node-cron, with an example that runs every six hours. That's a smaller footprint for an open source AI visibility tracker. Its documentation still asks you to keep the production process running, to persist the data/ folder, and to watch for SQLite locking if you run more than one instance.

I won't guess how many hours any of this takes, because nobody has measured it for you and a made-up number would only mislead you. A better test is to list what you would have to keep alive, and ask whether you'd be happy doing that on a week when a client deadline lands.

A managed plan moves the app, the database, the scheduled jobs and the browser infrastructure to the vendor. You still set up your prompts, your competitors and your provider keys, so it isn't zero work. It's a smaller list.

Data control, and what "self-hosted" really means

The main reason people give for self hosted AI brand monitoring is control of their data. That's a fair reason, but the word "self-hosted" doesn't promise it, so it's worth tracing where the data actually goes.

Take OneGlanse again. It stores captured answers, analysis results and provider sessions in your own stack. It also sends the captured answer text to whichever analysis model you configure, and the self-hosted workflow uploads your provider browser sessions from your computer to the VPS. The app also sends limited signup and activity telemetry to PostHog, and the documentation says that excludes prompts, saved answers, scores, names and email addresses. That's a fairly open description, which is useful, and it shows you that "on my server" and "nothing leaves" are two different claims.

Aperture shows the other side of local storage. It's an MIT-licensed MVP that stores data in a local SQLite file, and its README warns that API keys are stored unencrypted in that database and that the app has no authentication. It says to keep the instance on localhost or a private network, or put it behind an authenticated reverse proxy, and not to expose it to the public internet. So local storage isn't the same as secure storage, and you'd be the one who closes that gap.

When you look at any project, map each data flow yourself: where answers are stored, what goes to outside endpoints, how provider sessions and keys are kept, who can log in, and how backups work.

With a managed plan you're relying on the vendor's operations and terms instead. I can't tell you AeoNut's data residency or retention terms from what I have here, so check those on the vendor's own pages before you put a client's data in any managed tool, ours included.

Self-hosting doesn't remove outside fragility either. Collectors that read consumer websites depend on login sessions and on pages that change. Collectors that use APIs depend on the provider's API. Either way, part of the system sits outside your control.

Engine coverage and what counts as an answer

When a repository lists a set of engines, count the ones that are built, not the ones in the tagline.

Aperture's README marks ChatGPT and Perplexity as supported, and it lists Google AI Overviews and Claude as planned, with Gemini also planned in the provider documentation. OneGlanse documents five consumer interfaces. Prompt Clarity describes API integrations with five providers. Limelit, an Apache-2.0 project that calls itself pre-release, documents seven targets and is unusually clear about how each is collected: ChatGPT, Claude, Perplexity and Gemini through vendor APIs with web search turned on, and Google AI Overview, Google AI Mode and Bing Copilot through scrapers. It says that six of its eleven providers are implemented and five are not, and it supports one property per instance in v0.1.

By comparison, AeoNut's Free plan tracks twelve engines: ChatGPT, Gemini, Perplexity, Claude, Grok, Google AI Overviews, Google AI Mode, Mistral, Meta AI, Qwen, Z.ai and MiniMax. That includes the engines your clients most likely mean when they ask about AI search.

How an answer was collected matters as much as the count. Limelit says outright that a vendor API response with web search on is not the same thing as the consumer ChatGPT product. OpenAI's help page explains that ChatGPT can search the web, rewrite your query for the search provider, and, when memory is on, use saved memory in that rewrite and use approximate location for local results. Google says AI Overviews and AI Mode can both use query fan-out, and that they may use different models and techniques, so their answers and links can differ. For AI Overviews specifically, Google AI Overviews rank trackers compares what is free, and trackers for ChatGPT, Gemini and Perplexity does the same for those three.

So a tracker's run is a sample of one engine, one access mode, one account setup and one moment. It isn't a census of what the product tells everyone. Keep the prompt set and the access mode steady, don't merge API results with consumer-site results as if they were the same, and don't treat one changed answer as proof of a lasting shift.

Trend data and client-ready reports

If you're a consultant, the line that matters most is between a snapshot and a trend. A one-time checker gives you a baseline, and Ahrefs' free AI visibility checker is described that way, as a one-time snapshot. A baseline can open a conversation, but it can't show a client a month-over-month line.

For a trend, you need the same prompts running on a schedule, with the run dates and sample sizes kept, so you can say what changed and when. If keeping results over time is your main worry, free AI search monitoring tools that keep your history compares how long each one holds them. The projects you find for free LLM brand tracking GitHub searches vary here. Some keep answer histories and dashboards. Prompt Clarity documents APIs for its dashboard data but, in the material I reviewed, no export format or scheduled report delivery. Limelit documents JSON and streamed CSV export. Aperture lists scheduled audits, notifications and CSV or JSON export as roadmap items, which means planned, not shipped.

On AeoNut's Free plan, tracking is ongoing, with trends by engine, prompt and country, and white-label client reports that carry your branding, for one project. Don't promise a client a branded report from a repository unless its current documentation says it can make one.

A worked example with one client

Say you have one client, a regional accounting software company, and they've asked whether they appear when buyers ask AI assistants for tools in their category. You have thirty or so prompts from their sales team, three competitors, and a call with the client in a month.

On the self-hosted route, your first weeks go to picking a project, checking its license and its implemented engines, standing up the services, setting up storage and login, and working out how it collects answers. Only then do your prompts start running. If the project uses the consumer websites, you also deal with proxies and saved sessions. If it uses APIs, you're measuring a different surface and you'll want to tell the client that.

On the managed route, you sign up, add the same thirty prompts and the three competitors, pick the engines your client's buyers use, and the runs start on their schedule. By the call you may have a few weeks of data and a white-label report, and the time you saved goes into reading the answers and the cited sources.

Neither path is wrong. The first is a reasonable pick if the client is a security-sensitive company that wants the data on infrastructure you control, or if you plan to build a custom tracking service of your own. The second is a reasonable pick when the client wants an answer before the end of the month and you'd rather not become a part-time systems administrator.

Weighing the maturity of a project

Repository details tell you what a project says it does. They're not tests of how well it does it. OneGlanse showed 525 commits and a creation date of 9 September 2025 when I looked, which tells you it's active, and it doesn't tell you it's reliable. Limelit's pre-release label is a plain statement that long-term maintenance isn't established yet. I found no independent test of accuracy, uptime, setup time or total cost for any of these projects, so I'm not going to give you any.

Before you put a client's reporting on a repository, check the license, the current release status, how login and key storage work, how backups run, what goes to outside services, how the data is collected, and what happens when a provider session expires. You'd also be the one who has to apply upgrades.

Questions to ask before you commit

Whichever way you lean, a short list keeps you honest. None of these needs a test, only a read of the current documentation.

  • Does the license grant use, modification and sharing, and which license is it? MIT and Apache-2.0 are permissive. AGPL-3.0 adds a condition: if you run a modified version as a network service, you have to offer its users the matching source.
  • Which engines are implemented today, and which are only planned?
  • Is each engine collected through the consumer site, a scraper, or an API, and does the project label which?
  • Where do answers, keys and login sessions live, and who can reach them?
  • What calls leave your server, including analysis models and telemetry?
  • Can you export the data and produce a report your client will accept?
  • What happens when a provider session expires or a page changes?

If you can answer all seven from the documentation, you're in a good position to decide. If three or four stay vague, that's useful information too. This isn't legal advice on licenses, so read the license text itself for anything that matters to your business.

When each route wins

Pick a managed free plan if you need ongoing, client-ready tracking soon, you'd rather spend your hours on client work than on servers, one project is enough, and the engines and data terms fit. The Free plan is a good match for a one-brand pilot, and you can start free with AeoNut without a card. Remember the platform fee is zero while the provider data is billed to you separately. Free forever claims in this space are worth checking before you rely on one.

Look at self hosted AI brand monitoring if you truly need control of the application or the storage, or you want to change how it behaves, or you need something you can audit. You should also already be able to run and secure the services involved, and the project's built engines should match what you need to measure.

Don't choose the DIY route only because a repository is public or has no price. A public repository can have no license, a free codebase can still need servers, a self-hosted app can send data to outside endpoints, and an engine in a README can still be planned.

If you're torn, a sensible order is to start on a managed free plan, get a baseline and a few weeks of trend for your client, and then decide whether a specific need justifies the DIY work. That way the client conversation doesn't wait on your infrastructure. When the time comes to outgrow it, when a free plan is no longer enough covers the signs.

FAQs

Is an open-source AI visibility tracker free to run?

The software may have no subscription fee, but hosting and upkeep can still need resources, and some projects rely on outside services. The amounts vary by project, and I haven't priced them here.

Does self-hosted LLM tracking keep all my data private?

Not automatically. Look at storage, telemetry, provider sessions, any outside analysis endpoint, network exposure and login. Self-hosted describes where it runs, not that nothing leaves.

Will an API-based tracker show what people see in ChatGPT or Google AI Overviews?

Not necessarily. An API call with web search on and the consumer product are different surfaces, and Google documents that AI Overviews and AI Mode may use different techniques.

Is a one-time AI visibility checker enough?

It gives you a snapshot or baseline. It doesn't give you ongoing tracking or a trend, so check whether a free offer is a continuing plan or a single report.

Keep reading