AI Claims Verification: What 369 Unverified Claims Reveal

AI claims verification checks each factual statement an AI engine makes about your brand against facts you control, and most claims end up neither confirmed nor refuted. Of 698 claims ChatGPT, Gemini, Perplexity and Claude made about our brand, 369 (52.9%) came back "unverified". We hand-checked a random 60 of them: 41 were true facts our own site states, but the checker's fact sheet didn't list. Three were wrong.

So an unverified claim usually means your fact list is too short, and occasionally hides an error. By the end of this post you'll know what sits in the unverified pile, how to shrink it, which facts to publish so engines and checkers can confirm them, and how to triage the rest with a script.

Data used: 698 claims about bugviso.com extracted from 400 answers (50 buyer prompts × ChatGPT, Gemini, Perplexity and Claude × 2 runs on 2026-10-20, web search on) by BugViso's AI Visibility Tracker and checked against a fact sheet built from the brand's site. A random sample of 60 unverified claims (seed 20261029) was labelled by hand against bugviso.com's pricing, refund, terms and feature pages on 2026-10-29.

What "Unverified" Means in an AI Fact Check

A claim is unverified when the facts it's checked against neither confirm nor contradict it. An automated fact check works in three steps: extract each factual statement an answer makes about the brand, compare it with a fact sheet, and label it.

The rule that matters is the third line. "Not mentioned" isn't "wrong". BugViso's checker counts a claim as inaccurate only when it contradicts a specific line of the fact sheet; missing facts never count as errors. That keeps false alarms down, and it moves everything the sheet doesn't cover into the unverified pile.

The share was similar on every engine, unlike AI brand sentiment, where our per-engine means ranged from 58.2 to 71.4: 53.8% on ChatGPT, 48.8% on Gemini, 55.8% on Perplexity and 52.6% on Claude. Branded answers, where engines describe the brand at length, had 53.3% unverified; unbranded answers 49.4%. The pile isn't an engine quirk. It's a property of the fact sheet.

AI Claims Verification by Hand: 60 Unverified Claims

Two-thirds of the unverified claims we checked were true. We took a random 60 and checked each against our own pricing, refund, terms and feature pages:

The 95% interval on the true share is 56% to 79%, so "most unverified claims are true" holds even with a sample of 60. Applied to all 369, that's roughly 200 to 290 true statements engines made about us that the checker couldn't confirm.

The three false ones deserve a closer look, because they'd never surface as "inaccurate":

• "Doesn't run prompts against ChatGPT or Claude." Out of date: we launched an AI visibility tracker that does exactly that. The fact sheet didn't say so, so the checker couldn't object.
• "White-label on all three agency plans." We have four agency plans, all with white-label. The fact sheet listed a price range, not the plans.
• "Solves edge-level 403 blocks." An overstatement. The audit diagnoses AI crawler blocks and drafts fixes; it doesn't change your CDN.

💡 Rule of thumb: an unverified pile is mostly missing facts, with a few real errors hidden in it. Shrink it by adding facts, then read what's left.

What Kinds of Facts Go Unverified

Pricing details, plan limits and feature mechanics made up most of the pile. Sorting all 369 unverified claims by keyword (a rough sort, but enough to see the shape):

These are the facts buyers check: plan limits, what happens to unused scans, how refunds work, what exactly a feature inspects. Engines found them on our pages, or on pages describing us, and stated them; our post on documentation pages in AI citations shows which of our pages they read. A short fact sheet built from a site summary doesn't hold them, so the checker shrugs.

That's also why the earlier AI brand accuracy audit found one false alarm: a summary that said "plans from $19 to $149" couldn't confirm a true claim about the $49 tier. Ranges hide the middle. A good fact list names every plan.

Shrink the Pile by Publishing Checkable Facts

Every fact you want verified needs to exist twice: on a public page engines read, and in the fact list your checker uses. The first keeps engines accurate. The second lets you confirm that they are.

Write facts the way a checker can match them:

1. One fact per line, with the exact name and number. "Agency Starter: $49/month, 65 scans" beats "affordable plans for growing agencies".
2. List every plan, not the range. The middle tiers are what engines quote.
3. Include policies. Refund window, how to request one, cancellation, rollover rules. These were among our most-repeated unverified claims.
4. Include mechanics. "Crawls from the sitemap and rendered links", "evaluates robots.txt with RFC 9309 longest-match rules". Technical buyers ask, and engines answer from your docs.
5. Include limits. Pages per scan by plan, scans per month, what's not covered. Engines state limits whether you publish them or not.

The public side matters as much. The robots.txt rules we cite are defined in RFC 9309; a claim that names the standard is easy to confirm when your page names it too. Google's own guidance on AI features asks for important content in text form for the same reason. For prices, Google's documentation on Product structured data shows how offers carry price and currency in a machine-readable form, one more consistent copy of the same fact.

We tested the effect with the triage script below. Our first fact list had 12 lines. Adding 3 lines (pages per scan for each plan, how cancellation works, the scan schedules) moved 20 more unverified claims into "covered by a fact line": from 64 to 84 of 369.

Triage Your Own Unverified Claims

This script reads a claims export and a plain-text facts file (one fact per line). For every unverified claim it finds the closest fact line, requiring every number in the claim to appear in that line, and sorts the claim into: covered by a fact line, opinion or inference, not a claim about you, or needs a fact (or is wrong). It then lists the most repeated claims with no matching fact. It's a lexical first pass, not a judge. Standard library only.

#!/usr/bin/env python3
"""Triage the claims an AI fact check couldn't verify: which ones a line in your facts list
already covers, which are opinions or not claims at all, and which need a new public fact.

Usage: python3 claim_triage.py claims.csv facts.txt
claims.csv columns: verdict (accurate/inaccurate/unverified), claim.   facts.txt: one fact per line.
"""
import csv, re, sys
from collections import Counter

STOP = set("the a an and or of to for in on with its it is are be by as at per your you this that "
           "bugviso has have can will from than more most".split())
OPINION = re.compile(r"\b(better|best|cheaper|ideal|great|strong|weak|good for|suited|focused|"
                     r"may|might|could|likely|probably|generally|harsher|fast|simple)\b", re.I)
NOT_CLAIM = re.compile(r"(\?\s*$|\bI (couldn'?t|could not|can'?t|cannot)\b|\bverify\b|\bassuming\b|"
                       r"\bvendor[- ]provided\b|^treat\b)", re.I)

def tokens(s):
    return {t for t in re.findall(r"[a-z0-9$.%]+", s.lower().replace(",", "")) if t not in STOP and len(t) > 1}

def numbers(s):
    return set(re.findall(r"\d+(?:\.\d+)?", s.replace(",", "")))

def best_fact(claim, facts):
    ct, cn = tokens(claim), numbers(claim)
    scored = []
    for f in facts:
        ft, fn = tokens(f), numbers(f)
        if cn and not cn <= fn:      # every number in the claim must appear in the fact
            continue
        overlap = len(ct & ft) / max(1, min(len(ct), len(ft)))
        scored.append((overlap + 0.5 * bool(cn), f))
    return max(scored, default=(0.0, ""))

def main():
    if len(sys.argv) != 3:
        sys.exit(__doc__)
    facts = [l.strip() for l in open(sys.argv[2], encoding="utf-8") if l.strip()]
    rows = list(csv.DictReader(open(sys.argv[1], newline="", encoding="utf-8")))
    print("verdicts: " + ", ".join(f"{k} {v}" for k, v in Counter(r["verdict"] for r in rows).most_common()))
    out = Counter(); todo = []
    for r in rows:
        if r["verdict"] != "unverified":
            continue
        c = r["claim"]
        if NOT_CLAIM.search(c):
            out["not a claim about you"] += 1; continue
        score, fact = best_fact(c, facts)
        if score >= 0.5:
            out["covered by a fact line"] += 1
        elif OPINION.search(c):
            out["opinion or inference"] += 1
        else:
            out["needs a fact (or is wrong)"] += 1; todo.append(c)
    n = sum(out.values())
    for k, v in out.most_common():
        print(f"  {k:<28}{v:>5}  {100 * v / max(1, n):5.1f}%")
    print("\nmost repeated claims with no matching fact (add a public fact, or correct the claim):")
    for c, k in Counter(re.sub(r"\W+", " ", c.lower()).strip()[:90] for c in todo).most_common(10):
        print(f"  {k}x  {c}")

if __name__ == "__main__":
    main()

With our 15-line facts file it prints:

verdicts: unverified 369, accurate 319, inaccurate 10
  needs a fact (or is wrong)    243   65.9%
  covered by a fact line         84   22.8%
  opinion or inference           23    6.2%
  not a claim about you          19    5.1%

The "needs a fact" bucket is large because the matcher is strict: word overlap misses paraphrases. Treat it as a reading list sorted by repetition, not a verdict. The most-repeated lines in it are your next facts to publish. Replace bugviso in STOP with your own brand name.

How BugViso Verifies AI Claims About Your Brand

BugViso's AI Visibility Tracker checks every answer that mentions your brand against a fact sheet built from your site: what you offer, plans and prices, audience, locations, differentiators and the key facts on your pages. It extracts up to six claims per answer, each with a verbatim quote, and labels them accurate, inaccurate or unverified, with a correction for inaccurate ones. Before a run is scored, every "inaccurate" verdict is re-checked by a second model and kept only if it contradicts a specific line of the fact sheet, so the report doesn't ask you to correct facts that are already right.

You can edit the facts the checker uses: the plans, products and prices list and up to 10 key facts, and you can mark a flagged claim "This is actually correct" so it's accepted in every answer from then on. Accuracy is reported per engine with the unverified count beside it, and the action plan's fix-the-facts item can draft a key-facts page from your site. The fact check is part of the AI visibility tracker.

Verification Mistakes That Hide Real Errors

Reading accuracy without the unverified count. "97% accurate" over 329 checkable claims says nothing about the 369 nobody checked. Report both.

Feeding the checker a marketing summary. "Affordable plans for every team" can't confirm or refute anything. Give it the numbers.

Ignoring the false ones in the pile. Out-of-date product facts ("doesn't do X" after you launched X) only show up as unverified until your fact list says otherwise.

Treating opinions as errors. "Less of an all-in-one platform" is a judgement an engine is entitled to. Fix facts, not framings, unless the framing rests on a wrong fact.

Frequently Asked Questions

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

It means the facts the claim was checked against don't mention the thing claimed, so the checker can't confirm or refute it. In our data 52.9% of claims were unverified, and most of the ones we checked by hand were true facts missing from the fact sheet.

How do I verify what ChatGPT says about my company?

Extract each factual claim from the answer, then check it against a list of your own facts with exact names and numbers. Confirm the matches, correct the contradictions, and read the claims your list doesn't cover: those are either missing facts or errors your list can't see yet.

Why are so many AI claims about my brand unverifiable?

Because engines state detailed facts, such as plan limits, refund terms and how features work, that short brand summaries leave out. Publish those details on public pages and add them to the fact list your checker uses.

Are unverified AI claims usually wrong?

No. In our hand-checked sample of 60, 68% were true, 12% were opinions, 8% weren't claims and 5% were false or overstated. But the false ones matter, because a checker can't flag them until your facts cover the topic.

How many facts should my brand fact sheet have?

Enough to cover what buyers ask: every plan with its price and limits, your policies, your main features in plain terms and their limits. Our first 12-line list covered 64 unverified claims; three more lines covered 20 more.

Make the Unverified Pile Small Enough to Read

Most unverified claims are true facts your fact list never wrote down, so add exact plans, policies, mechanics and limits until the remainder is short, then read it for the few real errors hiding there. BugViso's AI visibility tracking fact-checks every answer against facts you can edit, so each line you add makes the next run's check sharper.