AI Brand Accuracy Audit: What ChatGPT Gets Wrong About You

An AI brand accuracy audit extracts the factual claims AI engines make about your brand and checks each one against your own site. We audited 698 claims that ChatGPT, Gemini, Perplexity and Claude made about our brand. 97% of the claims we could check were accurate, and all 10 claims flagged as wrong were about pricing, plans or quotas. One was a false alarm; another repeated a price we'd left in our own structured data.

The point of an accuracy audit isn't the headline percentage. It's finding the few wrong claims buyers actually act on, tracing each to its source and fixing the source. This playbook shows how: the data, the root causes, the fixes, and a script that checks price and quota claims automatically.

Data used: 141 answers that named our brand (bugviso.com, website-audit software), from 50 buyer prompts × 4 engines × 2 runs on 2026-10-20, with web search on. Claims were extracted and checked by BugViso's AI Visibility Tracker, then every inaccurate verdict was reviewed by hand.

Anatomy of an AI Accuracy Failure

An accuracy failure happens in three steps:

1. A buyer asks a factual question: "how much does BugViso cost", "is there a refund policy".
2. The engine retrieves pages and composes an answer. Some retrieved pages are yours, some are third-party, and some are stale copies.
3. The answer states a fact with confidence: "plans start at $49/month for 65 audits". The buyer doesn't click through to check.

The error can enter at retrieval (a stale or wrong source) or at composition (the engine misreads a correct source). The fix differs, so the audit has to tell them apart.

Reproduce It: What the Engines Claimed

Across the 141 answers that named the brand, the tracker extracted up to six claims per answer: 698 claims, or 4.95 per answer. Each got one of three verdicts against a fact sheet built from our site:

Two numbers matter more than the 97%:

• 53% of claims were unverified. Most were recommendations, advice to the reader, or facts the site doesn't state in checkable form. You can't fix what you can't check.
• All 10 flagged claims sat on one topic. Five were wrong price points, four described the plan structure wrongly, and one got a rollover window wrong. Nine of the ten came from branded prompts, where buyers are checking facts before they pay.

What "unverified" looked like in practice:

The middle row is the one to act on: it's a checkable fact the fact sheet didn't cover.

The 10 Inaccurate Claims, Reviewed

We reviewed every inaccurate verdict against our real pricing page. Quotes are verbatim from the answers.

Nine verdicts held up. The false alarm is instructive. The tracker's fact sheet summarised pricing as "$19 (20 scans) to $149 (300 scans)" without the middle tiers, so a true claim about the $49 tier looked wrong. An accuracy check is only as good as the facts you give it.

Top Root Causes, with Fixes

Root cause 1: Stale prices in your own markup

The "$29/month" claim has a likely source we're not proud of. Until 2026-10-08, the FAQ structured data on our own pricing page still listed old prices starting at $29, while the visible page said $19. Engines and the systems behind them read markup as well as visible text.

// ❌ Broken: FAQ JSON-LD left on old prices after a pricing change
{
  "@type": "Question",
  "name": "How much does it cost?",
  "acceptedAnswer": { "@type": "Answer", "text": "Plans start at $29/month." }
}

// ✅ Fixed: generate the markup from the same data as the visible pricing table
{
  "@type": "Question",
  "name": "How much does it cost?",
  "acceptedAnswer": { "@type": "Answer", "text": "Plans start at $19/month for 20 scans; single reports are $1.49." }
}

The fix is structural, not editorial. Render the pricing table, the FAQ answers and any Product or Offer markup from one data source, so a price change can't leave a copy behind. Our post on schema markup and AI citation accuracy covers the markup side.

Root cause 2: Ambiguous tier framing

Two engines said plans "start at $49". The $49 tier is real, but it's the tier our pricing page highlights as "Best Value". An engine that reads "Best Value: $49/month, 65 scans" can turn that into a starting price.

Fix: state the floor explicitly, in words, near the top of the page: "Plans start at $19/month for 20 scans." Don't leave the starting price to be inferred from a table. If you mark up prices, keep Offer values identical to the visible text.

Root cause 3: Missing or hard-to-read policy statements

Claude said our site "doesn't appear to describe a subscription plan". Monthly plans are on the pricing page. The engine either didn't retrieve that page or couldn't read the plan details from it.

Fix: put plan type, billing period and refund terms in plain HTML sentences, not only inside toggles, tabs or images. Make sure the page is reachable for AI crawlers; robots.txt rules for AI bots are a common cause of "can't find it", and the matching rules are defined in RFC 9309.

Root cause 4: Extrapolated ranges

"30 to 500 scans" and "60–90 days" are rounder versions of the truth (20–300, 60). Engines smooth numbers they half-remember from several sources.

Fix: repeat exact numbers in more than one place on your own site (pricing, FAQ, plan comparison), always identically. Correct third-party listings that quote old or rounded figures.

Check Price and Quota Claims Automatically

The tracker uses an AI model with a fact sheet to judge free-text claims. For the most common error class, price and quota numbers, a deterministic script is enough. Put your plans in facts.json, paste the claims (one per line) into claims.txt, and run:

#!/usr/bin/env python3
"""Check price and quota claims AI answers make about your brand against a fact sheet.

Usage: python3 claim_checker.py facts.json claims.txt
facts.json: {"plans": [{"name": "Starter", "price": 19, "quota": 20}, ...],
             "single_price": 1.49, "quota_words": ["scans", "audits", "reports"]}
claims.txt: one quoted sentence per line (copied from AI answers).
Verdicts: accurate (matches a real plan), inaccurate (a price/quota pair no plan has),
unverified (no checkable number).
"""
import json, re, sys

def check(claim, facts):
    words = "|".join(facts.get("quota_words", ["scans", "audits", "reports"]))
    prices = [float(x.replace(",", "")) for x in re.findall(r"\$\s?(\d[\d,]*(?:\.\d+)?)", claim)]
    quota = [int(x) for x in re.findall(rf"(\d[\d,]*)\s+(?:{words})", claim, re.I)]
    plans = facts["plans"]
    known_prices = {p["price"] for p in plans} | ({facts["single_price"]} if facts.get("single_price") else set())
    known_quotas = {p["quota"] for p in plans}
    if not prices and not quota:
        return "unverified", ""
    if prices and quota:
        pairs = {(p["price"], p["quota"]) for p in plans}
        if all((pr, q) in pairs for pr, q in zip(prices, quota)):
            return "accurate", ""
        return "inaccurate", "no plan has " + ", ".join(f"${pr:g} for {q}" for pr, q in zip(prices, quota))
    bad_p = [pr for pr in prices if pr not in known_prices]
    bad_q = [q for q in quota if q not in known_quotas]
    if bad_p or bad_q:
        return "inaccurate", "unknown " + ", ".join([f"price ${x:g}" for x in bad_p] + [f"quota {x}" for x in bad_q])
    return "accurate", ""

def main(facts_path, claims_path):
    facts = json.load(open(facts_path))
    tally = {"accurate": 0, "inaccurate": 0, "unverified": 0}
    for line in open(claims_path, encoding="utf-8"):
        claim = line.strip()
        if not claim:
            continue
        verdict, why = check(claim, facts)
        tally[verdict] += 1
        print(f"{verdict:<11} {claim[:80]}" + (f"   <- {why}" if why else ""))
    checked = tally["accurate"] + tally["inaccurate"]
    print("\n" + "  ".join(f"{k}: {v}" for k, v in tally.items()),
          f"  accuracy: {100 * tally['accurate'] / checked:.0f}%" if checked else "")

if __name__ == "__main__":
    main(sys.argv[1], sys.argv[2])

Our facts.json lists all four agency tiers, not just the range:

{"plans": [{"name": "Agency Lite", "price": 19, "quota": 20}, {"name": "Agency Starter", "price": 49, "quota": 65},
           {"name": "Agency Pro", "price": 99, "quota": 150}, {"name": "Agency Scale", "price": 149, "quota": 300}],
 "single_price": 1.49, "quota_words": ["scans", "audits", "reports"]}

Run on six real claims from the answers:

inaccurate  plans listed from $29/month   <- unknown price $29
accurate    plans start at $49/month for 65 audits
accurate    Listed at $149/month for 300 scans
unverified  unused scans roll over for up to 60 days
accurate    It offers a pay-per-audit model ($1.49 per report)
inaccurate  you receive a specific number of scans each month (ranging typically from 30 to    <- unknown quota 500

accurate: 3  inaccurate: 2  unverified: 1   accuracy: 60%

Note the limitation in line 2. The script confirms that $49 for 65 is a real plan, but it can't see that "start at" is wrong. Numeric checks catch invented prices and quotas; framing errors still need a reader or an AI judge with the full fact sheet. Extend check() with your own patterns for refund windows, rollover periods or seat counts.

Step-by-Step Remediation

1. Collect claims from branded prompts on every engine: price, plans, policies, integrations, locations.
2. Verdict each claim against a fact sheet that lists every tier and policy explicitly.
3. Review every "inaccurate" by hand. In our audit, 1 of 10 was the checker's fault.
4. Trace each real error to a source: your markup, an old page, a third-party listing, or an ambiguous sentence.
5. Fix the source, not the symptom: one data source for prices, explicit floors, plain-HTML policies.
6. Re-check over the next runs. Engines pick up changes at different speeds, so track the error until it stops appearing on every engine.

How BugViso Checks AI Claims About Your Brand

BugViso's AI Visibility Tracker runs an accuracy check on every answer that names your brand:

• A fact sheet from your own site. It's built from your confirmed brand profile: summary, category, offerings, audience, locations, differentiators and site claims. During setup, the brand brief has a "Facts AI should get right" field. That's where to list every plan tier, which would have prevented our false alarm.
• No extra call. Claims are checked in the same call that scores sentiment: up to 6 claims per answer, each accurate, inaccurate or unverified, with a correction for inaccurate ones.
• Verbatim quotes only. A claim is kept only if its quote appears word for word in the answer, so you can find it.
• Missing facts never count as wrong. A fact the sheet doesn't cover is unverified, not inaccurate.
• Grouped issues. Repeated wrong quotes are grouped with a count and the engines that made them. An accuracy rate based on fewer than 5 checkable claims is flagged low confidence.
• In the report. Inaccurate claims with their corrections appear in the web report and the PDF.

The accuracy view is part of the AI visibility tracker.

Traps and Edge Cases

Scoring accuracy on unbranded prompts only. Engines describe you in detail mostly when asked about you. 9 of our 10 errors came from branded prompts, so include them in the accuracy audit even though they're excluded from visibility.

Treating "unverified" as fine. 53% unverified means engines are saying things about you that your site doesn't state checkably. Publish the facts you want repeated.

Fixing the engine instead of the source. You can't edit an AI answer. You can edit the page, the markup and the third-party listing it came from.

Trusting a summary fact sheet. Ranges like "$19–$149" create false alarms on every true middle-tier claim.

One-run audits. Errors drift like everything else in AI answers (answer consistency data). A wrong price that shows up once in 20 answers is still a wrong price, and it may show up more next week.

FAQ

How do I check what ChatGPT says about my brand?

Ask it the branded questions buyers ask (price, plans, refunds, features) with web search on, extract each factual claim, and compare it with your own site. Repeat on Gemini, Perplexity and Claude, since each engine reads different sources.

How accurate are AI engines about brands?

In our audit, 97% of checkable claims were accurate across four engines, from 95.2% on Gemini to 98.8% on Perplexity. All of the errors were about pricing, plans or quotas.

Why does AI give the wrong price for my product?

The common causes are stale prices in your own markup or old pages, a highlighted mid-tier read as the starting price, rounded numbers from third-party listings, and plan details hidden in tabs or images. Fix the source and state the floor price in plain text.

Can I correct wrong information in AI answers?

Not directly. Correct the sources engines retrieve: your pages, structured data and third-party listings. Then re-check on later runs until the claim stops appearing.

What does "unverified" mean in an AI accuracy check?

The claim couldn't be confirmed or refuted from your fact sheet, either because it's an opinion or because your site doesn't state that fact. A high unverified share means you should publish more checkable facts.

Conclusion

AI engines are mostly right about brands, but the errors land on prices and plans where buyers decide, so audit branded answers on every engine and fix the source of each wrong claim, which is what BugViso's AI visibility tracking checks on every run.