Skip to content
Back to search

limelit

MarketplaceWorks with Claude CodeGitHubIncomplete

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today

Check it deeper on your machine

It has changed since its scan on 11 Nov 2026.

As a Claude Code plugin, install it and then ask Claude Code:

/plugin marketplace add keithmackay/mackayi/plugin install scanskillsafety@mackayiDo a deep scan of https://github.com/limelit-co/open with scanskillsafety

Or from a terminal, clone it and run it:

git clone https://github.com/keithmackay/scanskillsafety-skill ~/.claude/skills/scanskillsafetynode ~/.claude/skills/scanskillsafety/cli.cjs --deep 'https://github.com/limelit-co/open'

It checks the exact commit: every file, its packages against OSV (api.osv.dev), how it compares with this page's scan (findsafeskills.com receives the repository's address), and, if you agree, Claude reading every file with your own Claude subscription. It never runs the code.

Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/limelit-co--open/badge.svg)](/listings/limelit-co--open)

HTML

<a href="/listings/limelit-co--open"><img src="/api/listings/limelit-co--open/badge.svg" alt="findsafeskills safety rating" /></a>

Install

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

Ten minutes from nothing to a first number, in four steps, on macOS or Linux. Nothing to install first.

1. Download and start

mkdir -p ~/limelit && cd ~/limelit
curl -fsSL https://github.com/limelit-co/open/releases/latest/download/limelit_$(uname -s | tr A-Z a-z)_$(uname -m | sed 's/x86_64/amd64/;s/aarch64/arm64/').tar.gz | tar xz limelit
./limelit serve

Then open <http://localhost:1515>. The download is the newest build for your system, one file, `limelit`, in `~/limelit`. On start it prints every way to connect: the browser address, and lines for Claude Code, Claude Desktop and any other MCP client with your paths already filled in. The database is one SQLite file in `~/limelit/data`; back it up by copying it. Every build and its checksums are on the [releases page](https://github.com/limelit-co/open/releases).

The same binary two other ways:

# With Go 1.25 or newer
go install github.com/limelit-co/open/cmd/limelit@latest
limelit serve

# With Docker; the database lives in the limelit volume
docker run -p 1515:1515 -v limelit:/data ghcr.io/limelit-co/open

2. Set up in the browser

The setup wizard asks for your domain and reads your brand's name from your own site (answers write "Kindle to PDF", not "kindletopdf.com"), then your category and up to five competitors, fills a starter set of prompts, and takes one key. Two ways:

- **Free:** open <https://limelit.co/settings/open-key>, sign in with Google, press Create my key and paste it into the wizard. Or, in a second terminal, run `limelit login` (from the same folder as `limelit serve`), which opens that page and saves the key for you. It reaches ChatGPT, Gemini, Perplexity and Google's AI Overviews and AI Mode inside a free monthly allowance. Your prompts pass through Limelit Cloud to reach the engines; the answers are stored here. - **Your own keys:** the quickest is OpenAI's, which reaches ChatGPT. Settings lists every other provider with a link to where its key comes from. You pay them directly, with no limit from us.

If you already track this brand on Limelit Cloud, the prompts step offers to import your Cloud prompts and competitors instead of the starter set (the Prompts page has the same button later). After a run, the Competitors page suggests the sites your answers cite most.

Nothing is spent before you press Run. When the free allowance runs out, the failed answers say so; add your own key to keep going.

3. Press Run

One pass asks every prompt of every tracked engine. Answers appear on the Overview as each engine replies, usually inside a minute. Every number shows `n`, the answers it rests on, and under 20 says so.

4. Connect Claude

Claude Code:

claude mcp add limelit -s user -- sh -c 'cd ~/limelit && exec ./limelit mcp'

Claude Desktop, in `claude_desktop_config.json`:

{
  "mcpServers": {
    "limelit": {
      "command": "sh",
      "args": ["-c", "cd ~/limelit && exec ./limelit mcp"]
    }
  }
}

`~/limelit` is where step 1 put `limelit`. Claude starts `limelit mcp` in that directory so it reads the same `data` folder as the dashboard. If you put `limelit` somewhere else, change `~/limelit` to that directory, or copy the lines `limelit serve` prints, which carry your exact paths.

Then ask: "Get started with Limelit". You never need a tool name: the assistant checks where your instance stands, tells you the next step if setup or a first run is missing, and otherwise answers with your numbers and questions to ask next. Or go straight to "How visible is my brand in AI answers, and which prompts am I losing?" The tools are the same ones the dashboard reads, so the assistant's number is the screen's number.

From here, [Configuration](#configuration) covers the file and the environment, [Connect Claude (MCP)](#connect-claude-mcp) the remote endpoint and the tool catalog, and [docs/methodology.md](docs/methodology.md) what every number means.

Commands

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

.claude-plugin/marketplace.json · Manifest · 61 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. {
  2. "name": "limelit",
  3. "owner": {
  4. "name": "Limelit",
  5. "email": "hello@limelit.co",
  6. "url": "https://limelit.co"
  7. },
  8. "metadata": {
  9. "description": "Limelit plugins for AI search visibility: free site audits for AI crawlers and llms.txt, plus Limelit Cloud and Limelit Open connected to Claude.",
  10. "version": "0.1.0"
  11. },
  12. "plugins": [
  13. {
  14. "name": "limelit-audit",
  15. "source": "./plugins/limelit-audit",
  16. "description": "Free AI search audits with no account: which AI crawlers your robots.txt lets in, and whether your llms.txt is present and well formed.",
  17. "version": "0.1.0",
  18. "category": "marketing",
  19. "keywords": [
  20. "geo",
  21. "aeo",
  22. "ai-search",
  23. "robots-txt",
  24. "llms-txt",
  25. "seo"
  26. ]
  27. },
  28. {
  29. "name": "limelit",
  30. "source": {
  31. "source": "github",
  32. "repo": "limelit-co/limelit-plugin"
  33. },
  34. "description": "Connect Limelit Cloud: sign in from Claude Code with no API key, then see how ChatGPT, Claude, Perplexity, Gemini and Google AI answers rank and cite your brand, the prompts you lose, the sources to earn, and what to write next. Asks before anything that spends credits.",
  35. "version": "0.1.0",
  36. "category": "marketing",
  37. "keywords": [
  38. "geo",
  39. "aeo",
  40. "ai-visibility",
  41. "share-of-voice",
  42. "mcp"
  43. ]
  44. },
  45. {
  46. "name": "limelit-open",
  47. "source": "./plugins/limelit-open",
  48. "description": "Connect a self-hosted Limelit Open install: your own AI visibility tracking, read from Claude over the local limelit binary.",
  49. "version": "0.1.0",
  50. "category": "marketing",
  51. "keywords": [
  52. "geo",
  53. "aeo",
  54. "ai-visibility",
  55. "self-hosted",
  56. "open-source",
  57. "mcp"
  58. ]
  59. }
  60. ]
  61. }
README.md · README · 739 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. <h1 align="center">Limelit Open</h1>
  2. <p align="center">
  3. <strong>Self-hosted AI visibility tracking. One binary, your keys, your data.</strong>
  4. </p>
  5. <p align="center">
  6. Track how ChatGPT, Claude, Perplexity, Gemini, Google AI Overview and Google AI Mode
  7. <br />
  8. mention and cite your brand against your competitors, with an MCP server for AI visibility tracking built in.
  9. </p>
  10. <p align="center">
  11. <a href="LICENSE"><img alt="License: Apache 2.0" src="https://img.shields.io/badge/license-Apache--2.0-blue.svg"></a>
  12. <a href="go.mod"><img alt="Go 1.25+" src="https://img.shields.io/badge/go-1.25%2B-00ADD8.svg?logo=go&logoColor=white"></a>
  13. <a href="#status"><img alt="Status: pre-release" src="https://img.shields.io/badge/status-pre--release-orange.svg"></a>
  14. <a href="https://limelit.co"><img alt="Limelit Cloud" src="https://img.shields.io/badge/hosted-limelit.co-111.svg"></a>
  15. <a href="https://discord.gg/g2Ef3WSTTC"><img alt="Discord" src="https://img.shields.io/badge/chat-Discord-5865F2.svg?logo=discord&logoColor=white"></a>
  16. </p>
  17. https://github.com/user-attachments/assets/b5894a6e-bb40-426d-b493-2cedc7e41e90
  18. <p align="center">
  19. <sub>The launch film, 44 seconds with sound. Also on <a href="https://limelit.co/open">limelit.co/open</a>, or <a href="docs/video/limelit-open-launch.mp4">download the MP4</a>.</sub>
  20. </p>
  21. <p align="center">
  22. <a href="https://demo.limelit.co"><img alt="The race: every tracked brand's visibility by day, with a hover card for one measured day" src="docs/screenshots/race.png" width="880"></a>
  23. </p>
  24. <p align="center">
  25. <a href="https://demo.limelit.co"><img alt="Visibility by engine: every brand as a dot on a shared 0 to 100 track, one row per engine" src="docs/screenshots/by-engine.png" width="435"></a>
  26. <a href="https://demo.limelit.co"><img alt="Share of voice donut with the seven leading brands named and the rest grouped" src="docs/screenshots/share-of-voice.png" width="435"></a>
  27. </p>
  28. <p align="center">
  29. <strong>Live: <a href="https://demo.limelit.co">demo.limelit.co</a></strong> runs this repository unmodified. Read-only; the banner names the commit.
  30. <br />
  31. <sub>More screens below: the prompt by engine grid, the ranking, citations by source type, top cited sites, and visibility by question type.</sub>
  32. </p>
  33. ---
  34. Also known as **AEO** (Answer Engine Optimization), **GEO** (Generative Engine
  35. Optimization), **AIO** (AI Search Optimization) and **LLMO** (LLM
  36. Optimization). They are four names for the same question: when someone asks an
  37. AI assistant about your category, does your brand come up, and which sources
  38. does the answer trust?
  39. Limelit Open answers that on your own infrastructure. It is the open core of
  40. [Limelit](https://limelit.co), and it shares its tool names, engine ids and
  41. metric definitions, so moving to the hosted product is one command.
  42. ## Contents
  43. - [Status](#status)
  44. - [Screenshots](#screenshots)
  45. - [Why this exists](#why-this-exists)
  46. - [Features](#features)
  47. - [Quick start](#quick-start)
  48. - [Connect Claude (MCP)](#connect-claude-mcp)
  49. - [Claude plugins and skills](#claude-plugins-and-skills)
  50. - [Engines and providers](#engines-and-providers)
  51. - [Configuration](#configuration)
  52. - [How the numbers are computed](#how-the-numbers-are-computed)
  53. - [Cost](#cost)
  54. - [Compared with other AI visibility tools](#compared-with-other-ai-visibility-tools)
  55. - [Hosted only](#hosted-only)
  56. - [Glossary](#glossary)
  57. - [FAQ](#faq)
  58. - [Roadmap](#roadmap)
  59. - [Development](#development)
  60. - [Contributing](#contributing)
  61. - [License](#license)
  62. ## See it running
  63. **[demo.limelit.co](https://demo.limelit.co)** is this repository, unmodified,
  64. tracking a GPU cloud vendor against 21 competitors across six engines. The
  65. banner names the commit it runs. It is read-only. The history is a real
  66. company's data with the brand renamed to NorthWind, so the numbers are real
  67. measurements and the engines' answers are the ones they actually gave.
  68. ## Status
  69. **Pre-release. v0.1 is being built in the open.**
  70. What works today, verified against a live instance:
  71. - **One binary.** No Docker, no Node, no Postgres. It creates and migrates its
  72. own SQLite database on first start and serves the dashboard at
  73. `localhost:1515`.
  74. - **All seven engines.** ChatGPT, Claude, Perplexity and Gemini through their
  75. vendor APIs with web search on; Google AI Overview, Google AI Mode and Bing
  76. Copilot through scrapers, because those three have no API at all. Six
  77. providers of eleven are implemented; Settings lists the rest with a link to
  78. each key page.
  79. - **The full measurement chain.** Answers are stored, searched for your brand
  80. and every tracked competitor with the rank of the list item they appear in,
  81. and every cited source is classified as your own, a competitor's, social,
  82. informational or other.
  83. - **The numbers, on screen.** Visibility, share of voice, average position and
  84. citation share, each with the sample it rests on; the competitor ranking; the
  85. trend; visibility split by question type; and the prompt by engine grid.
  86. - **The evidence behind them.** Every answer readable in full with your brand
  87. marked in the text at the matcher's own offsets, the searches the engine ran
  88. on the way there, the brands it named with their ranks, and every source it
  89. cited.
  90. - **MCP.** `limelit mcp` over stdio, or streamable HTTP with a bearer token.
  91. Fourteen read tools on Limelit Cloud's names, so a conversation written
  92. against this server keeps working after an upgrade. The first one an
  93. assistant calls says where the instance stands (not set up, never run,
  94. ready) and what to do next, so a new user is never handed a 0%.
  95. - **Scheduling.** Daily or hourly inside `limelit serve`, or `limelit run` for
  96. one pass on demand, with a hard `runs_per_day` ceiling checked before any
  97. spend.
  98. - **Export.** `limelit export` writes the whole instance as one JSON document
  99. or a directory of CSVs, streaming, with a `--since` filter that reaches the
  100. rows hanging off each answer. `export_data` returns the same payload over
  101. MCP.
  102. - **Upgrade.** `limelit upgrade --key <cloud key>` uploads everything to a
  103. Limelit Cloud workspace and hands back its MCP endpoint. Nothing is deleted
  104. here, provider keys are never sent, and re-running after a dropped
  105. connection imports nothing twice.
  106. What does not work yet: five of eleven providers are unbuilt. Everything else
  107. in the table below is live.
  108. Everything marked *planned* below is tracked in
  109. [issues](https://github.com/limelit-co/open/issues) under the
  110. [v0.1 milestone](https://github.com/limelit-co/open/milestone/1). Watch
  111. releases to hear when it ships.
  112. ## Screenshots
  113. All taken from [demo.limelit.co](https://demo.limelit.co). Every number
  114. carries the sample it rests on, and every chart is server-rendered SVG that
  115. reads without JavaScript; hover adds detail, it never adds a value.
  116. <table>
  117. <tr>
  118. <td width="50%"><a href="docs/screenshots/grid.png"><img alt="Every prompt, every engine: a grid of fractions, worst prompts first, each cell a link to the answers behind it" src="docs/screenshots/grid.png"></a></td>
  119. <td width="50%"><a href="docs/screenshots/standings.png"><img alt="Where you stand: every tracked brand ranked by how often it is named, with share of voice and average position" src="docs/screenshots/standings.png"></a></td>
  120. </tr>
  121. <tr>
  122. <td><sub><strong>Every prompt, every engine.</strong> A fraction per cell, worst first. A dash is a prompt never asked of that engine, not a zero.</sub></td>
  123. <td><sub><strong>Where you stand.</strong> The ranking, with the mention and answer counts each rate rests on.</sub></td>
  124. </tr>
  125. <tr>
  126. <td><a href="docs/screenshots/who-gets-cited.png"><img alt="Who gets cited: one 100 percent stacked bar per measured day, split by source type, your share printed above each" src="docs/screenshots/who-gets-cited.png"></a></td>
  127. <td><a href="docs/screenshots/top-cited-sites.png"><img alt="Top cited sites, each classified as own, competitor, social, informational or other" src="docs/screenshots/top-cited-sites.png"></a></td>
  128. </tr>
  129. <tr>
  130. <td><sub><strong>Who gets cited.</strong> Each bar is one measured day's citations by source type; the number on top is your share.</sub></td>
  131. <td><sub><strong>Top cited sites.</strong> The pages the engines trust, classified. These are the pages you have to appear on or displace.</sub></td>
  132. </tr>
  133. <tr>
  134. <td><a href="docs/screenshots/by-question-type.png"><img alt="Visibility by question type: self-service, governed, GPU-first, sovereign-ready, multi-tenant, each with its own denominator" src="docs/screenshots/by-question-type.png"></a></td>
  135. <td><a href="docs/screenshots/race.png"><img alt="The race with a hover card listing every brand's value on one measured day" src="docs/screenshots/race.png"></a></td>
  136. </tr>
  137. <tr>
  138. <td><sub><strong>By question type.</strong> A question that names a rival lists rivals by construction, so each type is scored on its own.</sub></td>
  139. <td><sub><strong>The race.</strong> Calendar-proportional: a span nobody measured is shaded, never curved across. Hollow dots rest on thin samples.</sub></td>
  140. </tr>
  141. </table>
  142. ## Why this exists
  143. Most AI visibility platforms are closed SaaS. You send them your prompts, they
  144. send you a number, and how that number was computed is theirs. That is an
  145. awkward trade for a metric you are going to put in a board deck.
  146. Limelit Open takes the other side of it:
  147. - **Your infrastructure.** Prompts, competitors and every answer live in a
  148. SQLite file you own. Nothing leaves the box except the calls to the engines
  149. (made through Limelit Cloud when you use the free allowance).
  150. - **Your keys, your bill.** Bring your own provider keys. There is no pricing,
  151. no credits and no markup anywhere in this project, and no per-seat tax on
  152. looking at your own data. To try it first without buying any key, a free
  153. Limelit Cloud account gives a monthly allowance (see below).
  154. - **Auditable by construction.** Mentions are found by text search, not by a
  155. model deciding what it saw. Every metric is derived from stored rows and
  156. can be recomputed. The formulas are below and the code is right here.
  157. - **Honest about what is measured.** An answer from a vendor API with web
  158. search on is not the answer a person sees in ChatGPT. Both are useful, they
  159. are different surfaces, and every number carries which one it came from.
  160. ## Features
  161. | Feature | Status |
  162. |---|---|
  163. | **Visibility tracking**: how often each engine mentions your brand, per prompt and over time | **working** |
  164. | **Share of voice**: your mention rate next to every tracked competitor, on the same prompts | **working** |
  165. | **Citation analysis**: every URL an answer cited, classified as your own, a competitor, social, informational or other | **working** |
  166. | **Prompt by target grid**: one cell per prompt and engine, click through to the answers behind it | **working** |
  167. | **Hybrid providers**: vendor APIs and consumer-surface scrapers behind one interface, labeled on every metric | **6 of 11, all seven engines** |
  168. | **MCP server**: stdio and streamable HTTP, so Claude can read your visibility data and answer in plain language | **working** |
  169. | **Dashboard**: embedded in the binary, no Node, no separate frontend to deploy | **working** |
  170. | **Evaluation runner**: every active prompt against every enabled target, with usage counters and a hard `runs_per_day` ceiling | **working** |
  171. | **Scheduler**: daily or hourly in `limelit serve`, or `limelit run` for one pass on demand | **working** |
  172. | **Export**: JSON or CSV of everything, the same payload the Cloud upgrade sends | **working** |
  173. | **One-command upgrade**: move your property, prompts and history to Limelit Cloud | **working** |
  174. | **Query fan-out**: the searches an engine actually ran on the way to its answer, which are often not the question you asked | **working** |
  175. | **Setup wizard**: brand, competitors, a starter prompt pack from your category, one key | **working** |
  176. | **Single binary, SQLite**: no cgo, no Docker requirement, no Postgres | **working** |
  177. | **Press release publishing**: send a news article out through [PRNow](https://prnow.io) from the command line, then follow it to the outlets that ran it ([docs/prnow.md](docs/prnow.md)) | **new** |
  178. ## Quick start
  179. Ten minutes from nothing to a first number, in four steps, on macOS or
  180. Linux. Nothing to install first.
  181. ### 1. Download and start
  182. ```bash
  183. mkdir -p ~/limelit && cd ~/limelit
  184. curl -fsSL https://github.com/limelit-co/open/releases/latest/download/limelit_$(uname -s | tr A-Z a-z)_$(uname -m | sed 's/x86_64/amd64/;s/aarch64/arm64/').tar.gz | tar xz limelit
  185. ./limelit serve
  186. ```
  187. Then open <http://localhost:1515>. The download is the newest build for your
  188. system, one file, `limelit`, in `~/limelit`. On start it prints every way to
  189. connect: the browser address, and lines for Claude Code, Claude Desktop and
  190. any other MCP client with your paths already filled in. The database is one
  191. SQLite file in `~/limelit/data`; back it up by copying it. Every build and its
  192. checksums are on the [releases page](https://github.com/limelit-co/open/releases).
  193. The same binary two other ways:
  194. ```bash
  195. # With Go 1.25 or newer
  196. go install github.com/limelit-co/open/cmd/limelit@latest
  197. limelit serve
  198. # With Docker; the database lives in the limelit volume
  199. docker run -p 1515:1515 -v limelit:/data ghcr.io/limelit-co/open
  200. ```
  201. ### 2. Set up in the browser
  202. The setup wizard asks for your domain and reads your brand's name from your
  203. own site (answers write "Kindle to PDF", not "kindletopdf.com"), then your
  204. category and up to five competitors, fills a starter set of prompts, and takes
  205. one key. Two ways:
  206. - **Free:** open <https://limelit.co/settings/open-key>, sign in with Google,
  207. press Create my key and paste it into the wizard. Or, in a second terminal,
  208. run `limelit login` (from the same folder as `limelit serve`), which opens
  209. that page and saves the key for you. It reaches ChatGPT, Gemini, Perplexity
  210. and Google's AI Overviews and AI Mode inside a free monthly allowance. Your
  211. prompts pass through Limelit Cloud to reach the engines; the answers are
  212. stored here.
  213. - **Your own keys:** the quickest is OpenAI's, which reaches ChatGPT. Settings
  214. lists every other provider with a link to where its key comes from. You pay
  215. them directly, with no limit from us.
  216. If you already track this brand on Limelit Cloud, the prompts step offers to
  217. import your Cloud prompts and competitors instead of the starter set (the
  218. Prompts page has the same button later). After a run, the Competitors page
  219. suggests the sites your answers cite most.
  220. Nothing is spent before you press Run. When the free allowance runs out, the
  221. failed answers say so; add your own key to keep going.
  222. ### 3. Press Run
  223. One pass asks every prompt of every tracked engine. Answers appear on the
  224. Overview as each engine replies, usually inside a minute. Every number shows
  225. `n`, the answers it rests on, and under 20 says so.
  226. ### 4. Connect Claude
  227. Claude Code:
  228. ```bash
  229. claude mcp add limelit -s user -- sh -c 'cd ~/limelit && exec ./limelit mcp'
  230. ```
  231. Claude Desktop, in `claude_desktop_config.json`:
  232. ```json
  233. {
  234. "mcpServers": {
  235. "limelit": {
  236. "command": "sh",
  237. "args": ["-c", "cd ~/limelit && exec ./limelit mcp"]
  238. }
  239. }
  240. }
  241. ```
  242. `~/limelit` is where step 1 put `limelit`. Claude starts `limelit mcp` in that
  243. directory so it reads the same `data` folder as the dashboard. If you put
  244. `limelit` somewhere else, change `~/limelit` to that directory, or copy the
  245. lines `limelit serve` prints, which carry your exact paths.
  246. Then ask: "Get started with Limelit". You never need a tool name: the
  247. assistant checks where your instance stands, tells you the next step if setup
  248. or a first run is missing, and otherwise answers with your numbers and
  249. questions to ask next. Or go straight to "How visible is my brand in AI
  250. answers, and which prompts am I losing?" The tools are the same ones the
  251. dashboard reads, so the assistant's number is the screen's number.
  252. From here, [Configuration](#configuration) covers the file and the
  253. environment, [Connect Claude (MCP)](#connect-claude-mcp) the remote endpoint
  254. and the tool catalog, and [docs/methodology.md](docs/methodology.md) what
  255. every number means.
  256. ### Commands
  257. ```
  258. limelit serve dashboard, JSON API, MCP over HTTP, and the scheduler
  259. limelit mcp MCP over stdio, for Claude Desktop and Claude Code
  260. limelit run one evaluation pass, then exit
  261. limelit export write everything this instance knows to stdout
  262. limelit login get a free Limelit Cloud key and save it here
  263. limelit prnow publish a news article as a press release through PRNow
  264. limelit upgrade move this instance to Limelit Cloud
  265. limelit version version and build info
  266. ```
  267. ## Connect Claude (MCP)
  268. Limelit Open is MCP-first. The dashboard shows you the numbers; the MCP server
  269. lets an assistant read them, cross-reference them and quote the evidence. It
  270. can also start a run: it shows you the plan first, and runs only after you say
  271. yes.
  272. Claude Desktop or Claude Code, over stdio, set up as in
  273. [step 4 of the quick start](#4-connect-claude). `limelit mcp` reads `./data`
  274. in the directory it starts in, so it has to start where `limelit serve` runs,
  275. or be told the directory with `LIMELIT_DATA_DIR`. Started anywhere else it
  276. opens an empty database, not your instance.
  277. Remote clients point at `limelit serve` and its streamable HTTP endpoint at
  278. `/mcp`, sending a bearer token as `Authorization: Bearer <token>`. Generate
  279. the token in Settings (it is shown once and stored encrypted; Rotate and
  280. Forget take effect on the next request, no restart), or set
  281. `LIMELIT_MCP_TOKEN`, which wins over a generated one. Until a token exists the
  282. endpoint refuses every request: an open MCP endpoint would hand anyone who
  283. can reach the port every answer you have stored.
  284. Then ask things like:
  285. - "Get started with Limelit"
  286. - "How is Acme doing across AI engines this week?"
  287. - "Which prompts are we losing to Globex, and what do those answers cite instead of us?"
  288. - "Show me the answers behind our visibility drop, with the exact quotes."
  289. - "What did the engines actually search for when they answered that prompt?"
  290. Every metric a tool returns carries `n`, the answers it rests on, and the
  291. `api` or `scraped` access mode of each target. Arguments that only exist in
  292. Limelit Cloud, such as `segment`, are rejected with an explanation rather than
  293. silently ignored: a number scoped differently from what you asked for is worse
  294. than an error.
  295. Tool names mirror Limelit Cloud, so a conversation or a skill written against
  296. this server keeps working after you upgrade. Full catalog:
  297. [docs/tools.md](docs/tools.md).
  298. ## Claude plugins and skills
  299. This repository is also a Claude plugin marketplace. Add it once, then install
  300. the plugins you want:
  301. ```
  302. /plugin marketplace add limelit-co/open
  303. /plugin install limelit-open@limelit
  304. ```
  305. In the Claude desktop app or Cowork: **Plugins**, then **+ Add**, then **Add
  306. marketplace**, and enter `limelit-co/open`.
  307. | Plugin | What it does |
  308. |---|---|
  309. | [`limelit-open`](plugins/limelit-open) | Connects this install over stdio, with the skill `limelit-open-visibility-report`. Claude asks for the binary path and the data directory. |
  310. | [`limelit-audit`](plugins/limelit-audit) | Two skills that need no install and no account: `ai-crawler-check` (which AI crawlers a robots.txt lets in, and what each block costs) and `llms-txt-check` (audits a site's llms.txt and drafts a better one). |
  311. | [`limelit`](https://github.com/limelit-co/limelit-plugin) | Connects Limelit Cloud instead. You sign in through the browser from `/mcp`, with no key to paste. Adds skills, slash commands such as `/limelit:visibility` and `/limelit:next-post`, and a prompt before anything that spends credits or publishes. It lives in its own repo, [limelit-co/limelit-plugin](https://github.com/limelit-co/limelit-plugin), and installs from here too. |
  312. Details and privacy notes: [plugins/README.md](plugins/README.md).
  313. ## Engines and providers
  314. A **target** is one way of asking one engine, written
  315. `engine:provider[:model][:online]`:
  316. ```
  317. chatgpt:openai:gpt-5.5:online ChatGPT's model through OpenAI's API, web search on
  318. chatgpt:dataforseo:online chatgpt.com as a user sees it, through a scraper
  319. claude:anthropic:online
  320. perplexity:perplexity:sonar
  321. gemini:google:online
  322. ai_overview:dataforseo
  323. ai_mode:dataforseo
  324. bing_copilot:searchapi
  325. ```
  326. Two targets can point at the same engine. They are tracked separately and
  327. never averaged together, because they measure different things.
  328. **Engines**: `chatgpt`, `claude`, `perplexity`, `gemini`, `ai_overview`,
  329. `ai_mode`, `bing_copilot`.
  330. **Providers**:
  331. | Access | Providers | What it measures |
  332. |---|---|---|
  333. | `api` | `openai`, `anthropic`, `perplexity`, `google`, `openrouter` | The vendor's model with web search enabled, billed per token |
  334. | `scraped` | `dataforseo`, `searchapi`, `cloro`, `brightdata`, `oxylabs`, `olostep` | The consumer surface a person actually sees, billed per request |
  335. Adding a provider is one HTTP call, one response parse and a fixture, against
  336. a small Go interface. See [docs/providers.md](docs/providers.md); the open
  337. adapter issues are labeled
  338. [good first issue](https://github.com/limelit-co/open/issues?q=is%3Aissue+is%3Aopen+label%3A%22good+first+issue%22).
  339. ## Running a public demo
  340. Set `LIMELIT_DEMO=1` and the same binary becomes a read-only public instance:
  341. every button that would change or spend anything refuses with an explanation,
  342. the credential surface is hidden entirely, and the scheduler, if one is
  343. configured, keeps running so history accumulates. A banner names the exact
  344. commit the demo is built from and links to it, so a visitor can check that the
  345. demo is the open core and not a fork of it. [deploy/](deploy/README.md) is how
  346. demo.limelit.co is built and run.
  347. Configure the instance first, then set the flag. An unconfigured demo returns a
  348. plain error rather than a wizard nobody can submit.
  349. ## Configuration
  350. `limelit.yaml` holds what to track. It is meant to be committed and diffed, so
  351. it never holds a key.
  352. ```yaml
  353. property:
  354. name: Acme
  355. domain: acme.com
  356. aliases: [Acme Inc, acme.io]
  357. competitors:
  358. - { name: Globex, domain: globex.com }
  359. - { name: Initech, domain: initech.com }
  360. targets:
  361. - chatgpt:openai:gpt-5.5:online
  362. - claude:anthropic:online
  363. - perplexity:perplexity:sonar
  364. - ai_overview:dataforseo
  365. limits:
  366. runs_per_day: 200
  367. schedule: daily # daily, hourly, or off
  368. ```
  369. Credentials come from the environment (or the settings store, with the
  370. environment winning):
  371. ```
  372. OPENAI_API_KEY, ANTHROPIC_API_KEY, PERPLEXITY_API_KEY, GOOGLE_API_KEY,
  373. OPENROUTER_API_KEY, DATAFORSEO_LOGIN, DATAFORSEO_PASSWORD, SEARCHAPI_KEY,
  374. CLORO_API_KEY, BRIGHTDATA_API_TOKEN, OXYLABS_USERNAME, OXYLABS_PASSWORD,
  375. OLOSTEP_API_KEY
  376. ```
  377. `LIMELIT_DATA_DIR` sets where the SQLite database lives (default `./data`).
  378. `LIMELIT_SECRET` is the key that encrypts credentials pasted into the
  379. dashboard; leave it unset and one is generated beside the database.
  380. Everything under `limits` and `schedule` can also be changed in Settings while
  381. the server runs; a value saved there wins over the file, and the scheduler
  382. picks up a change within a minute. Settings also pauses and resumes a target
  383. (its answers stay, the runner skips it) and shows when each target last
  384. answered and last failed.
  385. One pass on demand, or one target on its own:
  386. ```bash
  387. limelit run --target chatgpt:openai:online
  388. ```
  389. ## How the numbers are computed
  390. Nothing here is a black box. This is the short version; the full method,
  391. with every formula, every exclusion and the test that enforces each one, is
  392. [docs/methodology.md](docs/methodology.md).
  393. 1. **You define the brands.** Your property (name, aliases, domain) and your
  394. competitors (name and domain; the domain is the identity key).
  395. 2. **Every active prompt runs against every enabled target**, on demand or on
  396. a schedule. Each answer is stored as text with the sources it cited.
  397. 3. **Mentions are found by text search.** For the names you gave us, in the
  398. text we stored. Rank comes from the enclosing list item when the answer is
  399. a ranked list. No model decides what it saw, so nothing can be invented
  400. and nothing is missed because a model stayed quiet.
  401. 4. **Citations are classified** by host: your own site, a tracked competitor,
  402. social, informational, or other.
  403. 5. **Metrics are aggregations over those rows**, and only those rows:
  404. | Metric | Definition |
  405. |---|---|
  406. | Visibility | share of answers that mention the brand |
  407. | Share of voice | the brand's mentions over all tracked brands' mentions in the same answers |
  408. | Position | mean rank where the brand appears in a ranked list |
  409. | Citation share | share of cited sources that are the brand's own site |
  410. Two denominator rules, because this is where visibility metrics usually go
  411. wrong:
  412. - **Prompts that name your own brand are tagged `branded`** and left out of
  413. the headline number. Asking an engine about yourself and counting the answer
  414. is the easiest way to inflate the metric.
  415. - **An answer surface that did not render is not a miss.** If a query produced
  416. no Google AI Overview at all, that run is excluded from the denominator
  417. rather than counted as an answer that ignored you.
  418. Every result carries `n`, the number of answers it rests on, so a number from
  419. four runs never gets read as a trend.
  420. ## Cost
  421. There is no pricing, no credits and no markup in this project. You pay your
  422. providers directly, at their rates.
  423. What the tool gives you instead:
  424. - **Usage counters**: calls and tokens per target per day, so you can
  425. reconcile against your own provider bill.
  426. - **A hard ceiling**: `limits.runs_per_day` (default 200). An evaluation that
  427. would exceed it is refused before anything is spent, and tells you by how
  428. much.
  429. - **No per-answer model call.** Mention detection is a text search, so the
  430. only thing you pay for is the answer itself.
  431. ## Compared with other AI visibility tools
  432. The commercial platforms in this category are good products with real
  433. capabilities this project does not have. The axis where an open core wins is
  434. control: reading the code behind every number, running it on your own
  435. infrastructure, and keeping the data.
  436. | | Open source | Self-hostable | Auditable metrics | Data ownership | Keys | Pricing |
  437. |---|---|---|---|---|---|---|
  438. | **Limelit Open** (this repo) | Yes, Apache-2.0 | Yes | Yes, the scoring code is this repo | Yours, a SQLite file | Bring your own | Free |
  439. | [**Limelit Cloud**](https://limelit.co) | Open core, this repo | Yes, by self-hosting this repo | Yes, the same definitions, published here | Vendor-hosted, exportable | Included | Commercial |
  440. | [Profound](https://www.tryprofound.com) | No | No | No | Vendor-hosted | Included | Commercial |
  441. | [Peec AI](https://peec.ai) | No | No | No | Vendor-hosted | Included | Commercial |
  442. | [Otterly.AI](https://otterly.ai) | No | No | No | Vendor-hosted | Included | Commercial |
  443. | [Scrunch AI](https://www.scrunchai.com) | No | No | No | Vendor-hosted | Included | Commercial |
  444. | [Ahrefs Brand Radar](https://ahrefs.com/brand-radar) | No | No | No | Vendor-hosted | Included | Commercial, bundled with Ahrefs |
  445. | [Semrush AI Toolkit](https://www.semrush.com) | No | No | No | Vendor-hosted | Included | Commercial, bundled with Semrush |
  446. Limelit is the only one of these with an open-source core: Limelit Cloud is
  447. the managed version of this project, and the metric definitions it uses are
  448. the ones published here. Choosing it is a hosting decision, not a lock-in one,
  449. and `limelit export` moves your data either way.
  450. Current prices change often; check each vendor's own pricing page.
  451. To be fair about where the commercial tools are ahead today: several offer
  452. prompt volume estimates, sentiment analysis, AI crawler analytics, on-page
  453. content optimization, and integration with an established SEO dataset. This
  454. project does none of those, and some of them are deliberately
  455. [hosted only](#hosted-only).
  456. ## Hosted only
  457. These are [Limelit Cloud](https://limelit.co) features and are not in the open
  458. core:
  459. - Query fan-out **rewrite analysis** (the capture itself is in the open core:
  460. every answer stores the searches the engine ran)
  461. - Prompt generation from your site, personas, competitor suggestion
  462. - Discovery of brands you did not list
  463. - Sentiment and framing, hallucination guard, correction drafts
  464. - Perception audits
  465. - Google Search Console and GA4
  466. - Agents, sheets and blocks
  467. - Portfolios and multi-brand, white-label, digest emails
  468. ### Moving to Limelit Cloud
  469. ```bash
  470. limelit upgrade --key <your Limelit Cloud API key>
  471. ```
  472. It uploads your property, competitors, prompts, answers, mentions, citations
  473. and fan-out, then prints the Cloud MCP endpoint to point your client at. The
  474. Limelit Cloud page in the dashboard runs the same move from a form.
  475. - **Nothing is deleted here.** The instance keeps everything, so a failed
  476. import is recoverable and leaving again is a command.
  477. - **No provider key is ever sent.** The payload is data. The OpenAI or
  478. Anthropic key that produced it stays on your machine.
  479. - **Re-running is safe.** Cloud keys each answer on your instance's own id, so
  480. an upgrade interrupted halfway and re-run imports nothing twice. It reports
  481. how many it skipped.
  482. - `--since 2026-06-01` narrows a large history.
  483. The same move is available to an agent as the `upgrade_to_cloud` tool. Called
  484. without a key it explains what Cloud adds and moves nothing.
  485. To keep measuring here and see the charts in ChatGPT, turn on **Sync to
  486. Limelit Cloud** in Settings instead: every run's answers are copied to your
  487. Cloud workspace, and ChatGPT charts them through the Limelit app. See
  488. [docs/chatgpt.md](docs/chatgpt.md).
  489. ## Glossary
  490. - **AI visibility**: whether and how a brand appears in answers generated by
  491. AI assistants, as distinct from ranking in a list of blue links.
  492. - **AEO, Answer Engine Optimization**: the practice of improving that.
  493. - **GEO, Generative Engine Optimization**: the same practice, different name.
  494. - **AIO, AI Search Optimization**: likewise.
  495. - **LLMO, LLM Optimization**: likewise.
  496. - **Answer engine**: a product that answers a question directly rather than
  497. returning links. ChatGPT, Perplexity, Google AI Overviews and AI Mode,
  498. Claude, Gemini, Copilot.
  499. - **Citation**: a source an answer engine attributes or links while answering.
  500. - **Share of voice**: your brand's share of all tracked brand mentions across
  501. the same set of answers.
  502. - **Prompt category**: the shape of the question. Discovery prompts ask for a
  503. recommendation without naming anyone, comparison prompts name a rival, use
  504. case prompts describe a job, brand prompts name you. Visibility is reported
  505. per category as well as overall, because an answer to "Rival alternatives"
  506. lists rivals by construction and reads as a loss if you score it the same
  507. way as "best tools for X".
  508. - **Query fan-out**: the web searches an engine runs to ground an answer
  509. before writing it.
  510. ## FAQ
  511. **Does this replace my SEO tool?**
  512. No. It measures a different surface. Traditional SEO tools measure ranked
  513. links; this measures what a generated answer says and cites.
  514. **Why does my ChatGPT number differ from what I see in ChatGPT?**
  515. Because an API call with web search on and the consumer product are different
  516. surfaces. Both are tracked, they are labeled `api` and `scraped`, and they are
  517. never averaged together. To measure what a person sees, use a scraped target.
  518. **Do I need a scraper account?**
  519. Not to start. One API key gets you running. Scrapers are what you add when you
  520. want the consumer surface or the Google AI surfaces, which have no API.
  521. **Does any of my data leave my machine?**
  522. Only the prompt text, in the calls to the engines and scrapers you configure.
  523. Answers, mentions, citations and usage stay in your SQLite file.
  524. **Can I track more than one brand?**
  525. Not in v0.1, which is one property per instance. Run several instances, or use
  526. the hosted product, which is built for portfolios.
  527. **What database does it use?**
  528. SQLite, pure Go, no cgo. A Postgres option is on the list, not in v0.1.
  529. ## Roadmap
  530. v0.1 is the first usable release: the wizard, the runner, the dashboard, the
  531. MCP server, the API providers and the first scrapers. Tracked in the
  532. [v0.1 milestone](https://github.com/limelit-co/open/milestone/1).
  533. After that: scraped ChatGPT and Gemini through LLM-scraper endpoints,
  534. multi-property per instance, Postgres as an alternative store.
  535. ## Development
  536. Go 1.25 or newer. No other toolchain: no Node, no Docker, no Postgres.
  537. ```bash
  538. make build # bin/limelit
  539. make test # go test ./...
  540. make lint # gofmt + go vet
  541. make run # build, then serve on :1515
  542. ```
  543. The screenshots in [docs/screenshots](docs/screenshots) are taken from
  544. demo.limelit.co at a 1440px viewport. When a chart or table changes shape,
  545. retake the ones it appears in; a README that shows a screen the binary no
  546. longer draws is worse than one with no pictures.
  547. Layout:
  548. ```
  549. cmd/limelit the binary and its verbs
  550. internal/config limelit.yaml plus credentials from the environment
  551. internal/store SQLite, embedded migrations, the repository layer
  552. internal/engines the tracked answer engines
  553. internal/provider the provider interface, typed errors, the registry, and the providers
  554. internal/target engine:provider[:model][:online]
  555. internal/promptpack the starter prompt templates
  556. internal/mentions the deterministic brand matcher and list ranking
  557. internal/citations URL normalisation and source classification
  558. internal/runner the evaluation runner: the ceiling, usage counters
  559. internal/metrics the read models every surface shares: visibility, share of
  560. voice, position, the grid, the answers
  561. internal/secrets encryption at rest for pasted provider keys
  562. internal/ui the embedded dashboard: templates, CSS, handlers
  563. internal/export the whole instance as JSON or CSV, streamed
  564. internal/upgrade the one-command move to Limelit Cloud
  565. internal/mcpserver the MCP tool catalog, on the official go-sdk
  566. internal/httpx HTTP surface: dashboard, JSON API, MCP over HTTP
  567. deploy/ the container, Litestream, and how the demo is deployed
  568. docs/ the tool catalog, the provider contract, the methodology
  569. ```
  570. ## Contributing
  571. Issues are labeled by area, and the provider adapters are deliberately small
  572. and self-contained. Start with
  573. [good first issue](https://github.com/limelit-co/open/issues?q=is%3Aissue+is%3Aopen+label%3A%22good+first+issue%22).
  574. [CONTRIBUTING.md](CONTRIBUTING.md) has the rules and the walk-through for
  575. adding a provider. The three worth knowing before a pull request:
  576. - Original code only. Do not copy code in from other projects.
  577. - Tests run offline. Every provider ships with recorded fixtures and tests
  578. that need no network and no keys.
  579. - Sign off your commits with `git commit -s`. That is the
  580. [Developer Certificate of Origin](https://developercertificate.org/): you
  581. are stating that you wrote the patch, or have the right to submit it under
  582. this license. There is no CLA and no copyright assignment; you keep the
  583. copyright in what you write.
  584. Questions or ideas: join the [Limelit Discord](https://discord.gg/g2Ef3WSTTC).
  585. ## License
  586. Apache-2.0. See [LICENSE](LICENSE) and [NOTICE](NOTICE).
  587. Copyright 2026 Limelit. The license is a grant, not a transfer: Limelit holds
  588. the copyright in the code it wrote, contributors hold the copyright in theirs,
  589. and everyone, including Limelit, uses the whole under Apache-2.0. You may run
  590. it, modify it, self-host it, and ship it inside a commercial product, provided
  591. you keep the license, the copyright notices, and the NOTICE file, and state
  592. what you changed.

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.