# LLMentions documentation (full) > Measure and improve how ChatGPT, Google AI Mode, Gemini, Claude and Perplexity mention and cite your brand. Agent-first over MCP, CLI and REST, with a confidence interval on every number. # Quickstart LLMentions measures how AI answer engines (ChatGPT, Google AI Mode, Gemini, Claude, Perplexity, Grok and others) mention and cite your brand, and audits whether those engines can read your site. It has three interfaces with the same capabilities and the same names: an **MCP server** for agents, the **`llmentions` CLI**, and a **REST API**. This page takes you from nothing to a real result. ## 1. Sign in and get your key Go to **[api.llmentions.com/login](https://api.llmentions.com/login)** and sign in with Google, GitHub or email. You get: - a workspace with **$1 of free usage**, no card needed - your **API key** (`sk_live_…`), shown once. Copy it into your secrets manager or shell: ```bash export LLMENTIONS_API_KEY=sk_live_… ``` Using the CLI? Skip the copy and paste. `llmentions login` opens the same sign-in page in your browser, confirms a one-time code, and saves the key to `~/.config/llmentions` with mode `0600`: ```bash llmentions login ``` > **Test keys are free.** Create one with `llmentions keys create dev --test` (or `POST /v1/keys` with `"test": true`). `sk_test_…` keys run against mock engines with realistic variance, return the same shapes and errors, and are never charged. Build against a test key, then swap in the live one. ## 2. Ask your first question Pick the interface you'll use most. All three call the same service and return the same data. **MCP (Claude Code shown; other clients in [MCP](/docs/mcp/))** ```bash claude mcp add --transport http llmentions https://api.llmentions.com/mcp \ --header "Authorization: Bearer $LLMENTIONS_API_KEY" ``` Then ask your agent: > Using llmentions, check how ChatGPT, Perplexity and Claude answer "best crm for startups", 5 samples each, and whether Acme is mentioned. Quote it first. The agent calls `account_get`, then `ai_answers` with `dry_run: true` for the price, then runs it. **CLI** ```bash llmentions ask "best crm for startups" --brand Acme --domain acme.com \ --competitor Rival --engines chatgpt,perplexity,claude -n 5 ``` **REST** ```bash curl -s https://api.llmentions.com/v1/ai/answers \ -H "authorization: Bearer $LLMENTIONS_API_KEY" \ -H 'content-type: application/json' \ -d '{ "prompts": ["best crm for startups"], "engines": ["chatgpt", "perplexity", "claude"], "samples": 5, "brand": "Acme", "domain": "acme.com", "competitors": ["Rival"] }' ``` Add `"dry_run": true` (or `--dry-run`) to get the exact price without running anything. Five samples on three engines is 15 answers: about $1.00 on these API engines, or $0.05 on queued consumer-app engines. ## 3. Read the result You get every answer in one normalized shape, plus a `report` because you passed `brand`: ```json { "data": { "answers": [ { "engine": "perplexity", "source": "api", "prompt": "best crm for startups", "mentions": [ { "brand": "Acme", "is_target": true, "position": 1 }, { "brand": "Rival", "is_target": false, "position": 2 } ], "citations": [ { "domain": "acme.com", "class": "owned" }, { "domain": "reddit.com", "class": "ugc" } ], "search_queries": ["best crm for startups 2026"] } ], "report": { "summary": "Acme was mentioned in 7/15 answers: 47% (95% CI 25–70%).", "samples": 15, "overall": [ { "brand": "Acme", "is_target": true, "mentioned": 7, "samples": 15, "rate": 0.47, "ci_low": 0.25, "ci_high": 0.70, "share_of_voice": 0.41 } ], "engines": [ "…per engine…" ], "sources": [ { "domain": "reddit.com", "class": "ugc", "answers": 6, "rate": 0.4 } ] } }, "meta": { "charged_usd": 1.0, "balance_usd": 0.0 } } ``` The fields that matter: - **`rate` with `ci_low` and `ci_high`.** Acme was named in 7 of 15 answers: 47%, with a 95% interval of 25–70%. The interval is wide because 15 answers is a small sample. See [Methodology](/docs/methodology/). - **`citations[].class`** tells you whether the engine cited you (`owned`), a competitor, a forum (`ugc`), a reference site, or other press (`earned`). - **`source`** says where an answer came from: the official `api` with native search, the consumer app (`ui`), or a `parametric` probe with search off. They are never pooled silently. > One answer is one sample. AI answers vary from run to run, so never act on a single answer. Use 5 or more samples per prompt and engine, and treat a change as real only when it is significance-tested. ## 4. Track your brand over time For ongoing measurement, create a project with the prompts your buyers ask, then run panels against it. Runs are stored and compared run-over-run with a two-proportion test. ```bash llmentions projects create Acme --domain acme.com --competitor Rival \ --prompt "best crm for startups" --prompt "hubspot alternatives for small teams" llmentions run Acme -n 5 --queued --dry-run # quote: queued consumer-app answers are $0.003 llmentions run Acme -n 5 --queued # starts the panel, waits, prints the report llmentions report Acme # latest run vs the previous one llmentions answers Acme --missing # the answers that left you out, and what they cited ``` Don't know which prompts to track? `llmentions suggest --category "crm for startups" --brand Acme --track` researches the buyer questions in your category and adds them. ## 5. Check that AI can read your site Being cited starts with being readable. AI crawlers don't run JavaScript, and many CDNs block them by default. ```bash llmentions audit acme.com ``` The audit crawls your site as AI bots see it, checks robots.txt for every AI bot, and lists issues most-severe first, each with a fix. See [Site audit](/docs/site-audit/). ## Where next - [MCP](/docs/mcp/): client setup and the full tool catalog - [CLI](/docs/cli/): every command, CI usage, running with your own provider keys - [REST API](/docs/api/): endpoints, errors, webhooks - [Billing](/docs/billing/): quotes, holds, refunds and plans - For agents: [`/llms.txt`](/llms.txt), [`/llms-full.txt`](/llms-full.txt), [`/pricing.json`](/pricing.json) and the [OpenAPI spec](https://api.llmentions.com/openapi.json) --- # MCP LLMentions is a remote MCP server using the streamable HTTP transport: - **URL:** `https://api.llmentions.com/mcp` - **Auth:** `Authorization: Bearer sk_live_…` or `sk_test_…`. [Sign in](https://api.llmentions.com/login) to get your key; see the [Quickstart](/docs/). - **Server name:** `llmentions` ## Clients ### Claude Code ```bash claude mcp add --transport http llmentions https://api.llmentions.com/mcp \ --header "Authorization: Bearer $LLMENTIONS_API_KEY" ``` ### Cursor, Windsurf and other JSON-configured clients Add this to the client's MCP config (for Cursor, `~/.cursor/mcp.json`): ```json { "mcpServers": { "llmentions": { "url": "https://api.llmentions.com/mcp", "headers": { "Authorization": "Bearer sk_live_…" } } } } ``` ### Clients that only speak stdio Use the `mcp-remote` bridge: ```json { "mcpServers": { "llmentions": { "command": "npx", "args": ["-y", "mcp-remote", "https://api.llmentions.com/mcp", "--header", "Authorization: Bearer ${LLMENTIONS_API_KEY}"], "env": { "LLMENTIONS_API_KEY": "sk_live_…" } } } } ``` ## Tools Every tool returns `{data, charged_usd, next}`: - `data` is concise by default. Pass `response_format: "detailed"` where it is supported to get everything. - `next` tells the agent what to do next. - Errors carry a hint, for example: `unknown engine(s): bard — call engines_list for valid keys`. | Tool | What it does | Cost | |---|---|---| | `account_get` | Workspace, key mode (live/test), balance, configured engines, webhook secret. **Call first.** | free | | `engines_list` | Engine keys and whether each is configured | free | | `ai_answers` | Ask engines now and get normalized answers and an optional mention report. Synchronous, ≤ 50 checks, nothing stored | per answer | | `project_list` / `project_create` | Brands you track: name, domain, competitors, prompts | free | | `prompts_track` | Add or remove tracked prompts | free | | `visibility_run` | Async panel: prompts × engines × samples. Supports `dry_run`, `queued` and `webhook_url` | per answer | | `job_get` | Poll a run; returns the report when it finishes | free | | `visibility_report` | Mention rate with 95% CI, share of voice, per engine and per prompt, top sources, and a significance-tested change vs the previous run | free | | `answers_search` | The raw stored answers. `missing_target=true` shows where you were absent | free | | `answers_analyze` | How engines *portray* each brand: sentiment, recommended vs listed, factual claims. Rates with 95% CIs, plus a verifier-agreement quality report | $0.002 / answer | | `prompts_suggest` | Researcher + critic agents find the buyer questions worth tracking in your category. `track: true` adds them | $0.02 / call | | `site_audit` | Can AI read your site? Crawls up to 100 pages as AI bots see them (no JavaScript), renders a few in a real browser to find content that needs JavaScript, checks robots.txt per AI bot and whether your CDN blocks them, and lists issues most-severe first with how to fix each. Stored, with what changed since last time | $0.0002 / page, $0.002 / rendered page | | `audit_get` | A stored audit (by id, or a domain's latest) and what changed since the one before. Poll this for background audits | free | | `bots_report` | Which search and AI bots really visit, from your server logs: hits, errors and top pages per bot, live AI fetches, and which hits are fakes (IP outside the vendor's published ranges) | free | | `stats_mention_rate` | Turn *k of n* into a rate with a 95% CI | free | ## A typical agent loop This is the loop a well-behaved agent runs. Every step is a tool call; nothing needs a human. 1. `account_get`: check the mode and balance. 2. `project_create` with 5–20 buyer-intent prompts. 3. `visibility_run` with `dry_run: true`, then run it for real. 4. Poll `job_get`, or pass a `webhook_url`. 5. `visibility_report`. Act only where `change_significant` is true. 6. `answers_search` with `missing_target: true`, to read the answers that left you out and see what they cite instead. 7. `answers_analyze`, to see whether you are recommended or merely listed, and to check what the engines claim about you. Start with `prompts_suggest` if you don't know which prompts to track. --- # CLI The `llmentions` CLI is a thin client over the REST API. Every command maps to an endpoint and an MCP tool, and `--json` prints the raw response for scripts and agents. > Prebuilt binaries ship with the public launch. Until then, build the CLI from source with `cargo install --path crates/cli`. ## Auth ```bash llmentions login # opens your browser to sign in, confirms a one-time code, saves the key llmentions login --key sk_live_… # headless: use a key you already have (or pipe it on stdin) llmentions account # workspace, mode, balance, engines llmentions logout ``` `llmentions login` uses a device-code flow: the CLI prints a short code and opens [api.llmentions.com/login](https://api.llmentions.com/login), you sign in with Google, GitHub or email, confirm the code, and the key is saved to `~/.config/llmentions` (mode `0600`). On a server with no browser, open the printed URL on any device. Key precedence is flags, then the environment (`LLMENTIONS_API_KEY`, `LLMENTIONS_API_URL`), then the config file. ## Output By default you get readable tables. Add `--json` to any command for the raw API envelope, so the CLI composes with `jq`, scripts and agents. Exit codes: `0` on success, `1` on an error or when a `--fail-on` condition trips, `2` on invalid arguments. ## Commands | Command | Does | API | |---|---|---| | `llmentions ask ""… [--brand B --domain D --competitor C] [-n N] [--engines a,b] [--dry-run]` | Ask engines now, print the answers or a mention report | `POST /v1/ai/answers` | | `llmentions projects` | List projects | `GET /v1/projects` | | `llmentions projects create --domain D [--competitor C]… [--prompt P]…` | Create a project | `POST /v1/projects` | | `llmentions track --add P --remove P` | Change tracked prompts | `POST /v1/projects/{p}/prompts` | | `llmentions run [-n N] [--engines …] [--queued] [--webhook URL] [--dry-run] [--no-wait]` | Start a panel, wait, print the report | `POST /v1/visibility/runs` | | `llmentions job ` | Job status and report | `GET /v1/jobs/{id}` | | `llmentions report [--all]` | Latest report vs the previous run | `GET /v1/projects/{p}/visibility` | | `llmentions answers [--missing] [--engine E] [--brand B] [-q text]` | Read stored answers | `GET /v1/projects/{p}/answers` | | `llmentions analyze [--all] [--force] [--dry-run]` | Sentiment, recommended vs listed, and claims per brand | `POST /v1/projects/{p}/analyze` | | `llmentions suggest --category "…" [--project P \| --brand B] [-n N] [--track]` | Research the buyer questions worth tracking | `POST /v1/prompts/suggest` | | `llmentions audit [--max-pages N] [--render N] [--fail-on error\|warning\|regression] [--pages]` | Can AI answer engines read your site, and what's in the way? Shows what changed since the last audit. `--fail-on` exits 1 for CI | `POST /v1/site/audit` | | `llmentions audits ` | A stored audit and what changed since the previous one | `GET /v1/site/audits/{audit}` | | `llmentions bots ` | Which search and AI bots visit, from server logs, with fake bots flagged by IP | `POST /v1/bots/report` | | `llmentions keys list \| create [--test] \| revoke ` | Manage API keys | `/v1/keys` | | `llmentions prices` | Public price list | `GET /v1/prices` | | `llmentions engines` | Engines configured locally | (local) | ## In CI (GitHub Actions) Fail a pull request when the site, or its preview deploy, stops being readable by AI: ```yaml - uses: williamrogersdev/llmentions@main with: site: ${{ steps.deploy.outputs.url }} # or example.com api-key: ${{ secrets.LLMENTIONS_API_KEY }} fail-on: regression # or: error, warning, none ``` The audit is printed to the job summary. Test keys (`sk_test_…`) audit for free. ## Run locally with your own keys `--local` runs the same panel code on your machine, using provider keys from `.env` (`OPENAI_API_KEY`, `ANTHROPIC_API_KEY`, `GEMINI_API_KEY`, `PERPLEXITY_API_KEY`, `XAI_API_KEY`, `DEEPSEEK_API_KEY`, `DASHSCOPE_API_KEY`, `MOONSHOT_API_KEY`, `DATAFORSEO_LOGIN`/`DATAFORSEO_PASSWORD`). You pay the providers directly. `--mock` uses demo engines and needs no keys. ```bash llmentions ask "best crm for startups" --brand Acme --local -n 5 llmentions ask "best crm for startups" --brand Acme --mock ``` --- # REST API - **Base URL:** `https://api.llmentions.com` - **Spec:** [`/openapi.json`](https://api.llmentions.com/openapi.json) (OpenAPI 3.1) - **Auth:** `Authorization: Bearer sk_…` (or an `x-api-key` header). [Sign in](https://api.llmentions.com/login) to get a key. - **Idempotency:** send `Idempotency-Key` on cost-bearing `POST`s to make retries safe. ## Envelope Every response looks like this: ```json { "data": { }, "meta": { "charged_usd": 0.15, "balance_usd": 4.85, "cached": false, "truncated": false } } ``` `charged_usd` is what the call cost. It is 0 for reads of stored data, for dry runs, and for test keys. ## Errors Errors use real HTTP status codes and always tell you what to do next: ```json { "error": { "type": "budget_exceeded", "message": "insufficient balance: this run costs $1.2000, balance is $0.4000", "hint": "lower `samples` or prompts, use a test key (free mock engines), or top up the balance" } } ``` | Status | `type` | |---|---| | 400 | `invalid_request` | | 401 | `auth` | | 402 | `budget_exceeded` | | 403 | `forbidden` | | 404 | `not_found` | | 429 | `rate_limited` (with `retry_after`) | | 502 | `upstream` | ## Endpoints | Method and path | Purpose | Cost | |---|---|---| | `GET /v1/account` | Workspace, mode, balance, engines, `webhook_secret` | free | | `GET /v1/engines` · `GET /v1/prices` | Engines and the price list. No auth | free | | `POST /v1/ai/answers` | Ask engines now (synchronous) | per answer | | `GET/POST /v1/projects` | List or create projects | free | | `POST /v1/projects/{p}/prompts` | `{add, remove}` tracked prompts | free | | `POST /v1/visibility/runs` | Start a panel. Returns `202` with `Location: /v1/jobs/{id}` | per answer | | `GET /v1/jobs/{id}` | Job status, progress, charge, report | free | | `GET /v1/projects/{p}/visibility` | Latest report (`?all_runs=true` pools every run) | free | | `GET /v1/projects/{p}/answers` | Stored answers (`engine`, `brand`, `missing_target`, `q`, `limit`) | free | | `POST /v1/projects/{p}/analyze` | `{all_runs?, force?, dry_run?}` labels answers with the analysis squad and returns perception rates per brand | $0.002 / answer | | `POST /v1/site/audit` | `{url, max_pages?, render?, bot_view?, background?, dry_run?}` crawls as AI bots see the site; returns `{audit_id, audit: {status, report}, changes}`. Above 25 pages it runs in the background | $0.0002 / page crawled, $0.002 / page rendered | | `GET /v1/site/audits/{audit}` | A stored audit by id, or a domain's latest, with `changes` since the previous audit | free | | `POST /v1/bots/report` | `{log}` raw server log (≤ 20 MB) returns hits, status codes, top paths and IP verification (verified / spoofed / unverifiable) per bot | free | | `POST /v1/prompts/suggest` | `{category, brand? or project?, competitors?, audience?, n?, locale?, track?}` returns buyer questions by intent | $0.02 / call | | `GET/POST /v1/keys` · `DELETE /v1/keys/{id}` | Manage keys | free | | `GET /v1/bots/lookup?ua=…` | Identify an AI or search crawler from its User-Agent | free | `{p}` takes a project id, its name or its domain. Names are case-insensitive. ## `POST /v1/ai/answers` | Field | Type | Notes | |---|---|---| | `prompts` | string[] | required | | `engines` | string[] | `chatgpt`, `chatgpt_ui`, `google_ai_mode`, `gemini`, `claude`, `perplexity`, `grok`, `deepseek`, `qwen`, `kimi` (experimental). Omit for all configured engines | | `samples` | int | 1–10, default 1. Prompts × engines × samples ≤ 50 | | `locale` | string | BCP-47, default `en-US` | | `web_search` | bool | `false` runs a parametric probe: what the model "knows" without searching | | `brand`, `brand_aliases`, `domain`, `competitors` | | optional. Adds mention detection, citation classes and a `report` | | `dry_run` | bool | returns the quote only | Each item in `answers` has these fields: - `engine`, `source`, `model_version`, `prompt`, `text` - `mentions[] {brand, is_target, position, count}` - `citations[] {url, domain, title, position, class}` - `search_queries[]`, `latency_ms`, `refused` ## `POST /v1/visibility/runs` `{project, prompts?, engines?, samples (1–50, default 5), locale?, web_search?, queued?, webhook_url?, dry_run?}` - **Quote first.** `dry_run: true` returns `{checks, price_usd, engines, missing}`. - **Billing.** A real run holds the quoted price up front. When it finishes, only successful answers are charged and the rest is refunded. - **`queued: true`** uses the standard queue for consumer-UI engines (`chatgpt_ui`, `google_ai_mode`). It costs $0.003 instead of $0.01 per answer, and results take minutes instead of seconds. ## Webhooks Pass `webhook_url`, a public `https://` URL, and we POST the finished job to it: ``` POST /your/hook Content-Type: application/json LLMentions-Signature: t=1795219200,v1=5f1c… {"type":"job.finished","job":{"id":"…","status":"succeeded","charged_usd":0.6,"report":{…}}} ``` To verify a delivery, compute HMAC-SHA256 over `"."` with your workspace's `webhook_secret` (from `GET /v1/account`), compare it in constant time, and reject a `t` older than 5 minutes. ```js import { createHmac, timingSafeEqual } from "node:crypto"; export function verify(rawBody, header, secret) { const { t, v1 } = Object.fromEntries(header.split(",").map((p) => p.split("="))); if (Math.abs(Date.now() / 1000 - Number(t)) > 300) return false; const want = createHmac("sha256", secret).update(`${t}.${rawBody}`).digest("hex"); return timingSafeEqual(Buffer.from(want), Buffer.from(v1)); } ``` ```python import hashlib, hmac, time def verify(raw_body: bytes, header: str, secret: str) -> bool: parts = dict(p.split("=", 1) for p in header.split(",")) if abs(time.time() - int(parts["t"])) > 300: return False want = hmac.new(secret.encode(), f'{parts["t"]}.'.encode() + raw_body, hashlib.sha256).hexdigest() return hmac.compare_digest(want, parts["v1"]) ``` Delivery details: - We make up to 3 attempts, at 0 s, 5 s and 30 s. - Redirects are not followed. - Private and link-local addresses are refused. - If delivery fails, it is noted in the job's `errors`, so `GET /v1/jobs/{id}` stays the source of truth. --- # Site audit An engine can only cite what it can read. Most sites that are invisible in AI answers have a mechanical cause: robots.txt blocks the bots that build AI search indexes, a CDN rule challenges them, or the main content only appears after JavaScript runs, which AI crawlers don't do. `site_audit` finds those causes and tells you how to fix each one. `bots_report` then confirms, from your own server logs, which bots actually visit. ## Run an audit ```bash llmentions audit acme.com ``` Or with MCP (`site_audit`) or REST: ```bash curl -s https://api.llmentions.com/v1/site/audit \ -H "authorization: Bearer $LLMENTIONS_API_KEY" \ -H 'content-type: application/json' \ -d '{"url": "https://acme.com", "max_pages": 100, "render": 5}' ``` What the audit does: 1. **Reads robots.txt for every known AI and search bot**, and reports which ones are allowed or blocked: training bots, AI search indexers and live user-fetch bots are listed separately, because blocking each has different consequences. 2. **Fetches your homepage as an AI bot and as a browser** and compares the two, to catch CDN and WAF rules that challenge AI user agents. 3. **Crawls up to `max_pages` pages (default 25, at most 100) without JavaScript**, the way AI crawlers see them, and records the text, title, headings, canonical, structured data and response time. 4. **Renders up to `render` pages in a real browser** (default 3, at most 10; homepage and thinnest pages first) and compares the text, to find content that only exists after JavaScript. 5. **Lists issues most-severe first**, each with the pages affected and a fix. Audits above 25 pages run in the background; poll `audit_get` (or `llmentions audits acme.com`). Every audit is stored, and each new one reports what changed since the previous one: new issues, fixed issues and AI-bot access changes. ## Example output ```text acme.com · 48 pages · 5 rendered · 2.1 s AI access OAI-SearchBot ✓ ChatGPT-User ✓ PerplexityBot ✗ Claude-SearchBot ✓ GPTBot ✗ (training) ERROR ai_search_blocked robots.txt blocks an AI search or answer bot PerplexityBot → allow search_index and user_fetch bots; blocking them keeps you out of AI answers ERROR content_needs_js Most of the content only appears after JavaScript runs 12 pages → server-render (SSR/SSG) the main content WARNING slow_response Slow server response (over 800 ms) 3 pages NOTICE no_structured_data No JSON-LD structured data 48 pages since last audit: 1 new, 2 fixed, 0 changed issue(s); 0 AI-bot access change(s) ``` Every check, what it means and how to fix it is listed in the [audit checks reference](/checks/). ## Price $0.0002 per page crawled and $0.002 per page rendered. A 100-page audit with 5 rendered pages costs $0.03. Test keys audit for free. ## Fail CI when your site stops being readable ```bash llmentions audit https://preview-123.acme.dev --fail-on regression ``` `--fail-on` takes `error`, `warning` or `regression`, and exits `1` when it trips. There is a ready-made GitHub Action in [CLI → In CI](/docs/cli/#in-ci-github-actions). ## Verify real bot traffic Your robots.txt says who may crawl. Your logs say who actually did. Send a raw access log (up to 20 MB) to `bots_report`: ```bash llmentions bots /var/log/nginx/access.log ``` You get hits, status codes and top pages per bot, the live AI fetches (a proxy for real-time citations), and **IP verification**: a hit claiming to be GPTBot from outside OpenAI's published ranges is flagged as spoofed. `bots_report` is free. The [AI crawler directory](/bots/) lists every bot we recognise, what it's for, and whether you should allow it. --- # Methodology AI answers are non-deterministic: the same prompt asked twice can name different brands. A single answer is an anecdote, not a measurement. LLMentions is built around that fact. ## Every rate is a proportion with an interval A mention rate is *k* mentions in *n* sampled answers. We always report it with a **95% Wilson score interval**, which behaves well at small *n* and near 0% or 100%. For example: > Mentioned in 3/10 answers: 30% (95% CI 11–60%). The wide interval is the point: ten samples cannot tell 30% apart from 50%. Use `samples` of 5 or more per prompt and engine, and more prompts, to tighten it. `stats_mention_rate` computes the interval for any *k*/*n*. ## Changes are tested, not eyeballed Run-over-run changes use a **two-proportion z-test**. Reports include `change.delta` and `change.significant`, and you should treat a change as real only when `significant` is true. Overlapping intervals mean there is no evidence of change. ## Every observation is labelled with its source | `source` | Meaning | |---|---| | `api` | The provider's official API with its own native web search or grounding (OpenAI `web_search`, Gemini Google Search grounding, Claude web search, Perplexity, xAI) | | `ui` | What a real user sees in the consumer app (ChatGPT, Google AI Mode), via a licensed data provider | | `parametric` | API with search disabled: what the model "knows" from training | API and app answers differ, sometimes a lot, so they are never pooled silently. We call each provider's *native* search rather than a normalizing gateway, because each engine's own citation behaviour is the signal. ## Mentions and citations - **Mentions** match your brand name and aliases on word boundaries, and record the order of first appearance among the tracked brands. - **Citations** are deduplicated, kept in order, and classed as: - `owned`: your domain - `competitor`: a tracked competitor's domain - `ugc`: Reddit, forums, YouTube and similar - `reference`: Wikipedia, review sites and similar - `earned`: everything else **Share of voice** is your mentions divided by all tracked-brand mentions. --- # Billing **Credits are dollars.** Prices and balances are in USD, and every response says what it cost (`meta.charged_usd`). ## How a charge works 1. **Quote.** Any run accepts `dry_run: true` and returns the exact maximum price. Nothing is charged. 2. **Hold.** When a run starts, its quote is reserved from your balance. Concurrent runs can't overdraw it. If the balance is too low you get a `402` with a hint. 3. **Settle.** Only **successful** answers are charged. Failed provider calls, timeouts and engines that are not configured are refunded automatically. ## Prices See [Pricing](/pricing/) or [`/pricing.json`](/pricing.json). The same list is served live at `GET /v1/prices`. | Answer type | Price | |---|---| | Consumer app answer (`chatgpt_ui`, `google_ai_mode`), queued | $0.003 | | Consumer app answer, live | $0.01 | | API + web search (`chatgpt`, `gemini`, `perplexity`, `deepseek`, `qwen`, `kimi`) | $0.05 | | Premium model + web search (`claude`, `grok`) | $0.10 | | Parametric probe (search off) | $0.005 | | Answer analysis (agent squad), per answer labelled | $0.002 | | Site audit, per HTML page crawled | $0.0002 | | Site audit, per page rendered in a browser | $0.002 | | Prompt research (agent squad), per call | $0.02 | Reading stored data is always free: reports, answers, jobs, accounts, quotes and statistics. ## Test keys are free `sk_test_…` keys run against mock engines that produce realistic, varied answers. They exercise the same code paths, envelopes, errors and reports as live keys, and **are never charged**. Build and test your agent on a test key, then switch the key. ## Free usage and top-ups - Every workspace gets **$1 of free usage each month** after you [sign in](https://api.llmentions.com/login). No card needed. That is 333 queued consumer-app answers, or 20 API answers with search. - **Pay-as-you-go:** top up from $10. Credits never expire. - **Plans** are prepaid usage with a bonus, not feature gates: Builder ($49/mo for $60 of usage), Pro ($199/mo for $260), Agency ($599/mo for $840). Unused plan usage rolls over one month. See [Pricing](/pricing/). - We never charge per seat, per domain, or per engine.