You typed your company name into ChatGPT and got a description that is a year out of date. Or a competitor's pricing. Or nothing at all. If you searched "chatgpt wrong information about my brand," you are past the point where a generic visibility checklist helps. You need to find out why the engine says what it says, then change the facts it works from.
That is a diagnostic job, not a content-volume job. This guide covers it in order: name the failure, test it cleanly, trace the claim to a source, rule out access problems, correct the facts where they live, and re-test. It applies to ChatGPT, Gemini, and Perplexity, and it stays on repair rather than long-term authority building.
Name the Failure Before You Fix Anything
"AI gets us wrong" hides four different problems, and each one has a different repair. Sort yours first.
- Omission (presence). The engine never names your brand, even when the prompt describes exactly what you sell.
- Misdescription (accuracy). The engine names you but states wrong or outdated facts: the wrong category, old pricing, a discontinued product.
- Wrong context. You appear, but beside the wrong competitors or in the wrong use case.
- Instability (movement). You are right one week and wrong the next, or right on one engine and absent on another.
A common mistake is to treat every one of these as a shortage of content. Publishing more pages rarely fixes a brand whose own site, bios, and listings disagree with each other. It also does nothing for a brand whose correct pages are blocked from the crawlers that feed the answer.
Step 1: Build a Test Set You Can Repeat
Pick eight to ten prompts, phrased the way a real buyer would type them. Keyword fragments tell you little. Full questions tell you how an assistant behaves when someone is deciding.
Cover four prompt types so each failure mode has a chance to show up:
- Direct brand questions: "What does [Brand] do?" and "Who is [Brand] for?"
- Category questions: "What are the best [category] options for [audience]?"
- Comparison questions: "[Brand] vs [Competitor]" and "alternatives to [Competitor]."
- Fact checks: pricing, location, founding date, current product names, key features.
Run the same set, word for word, in ChatGPT, Gemini, and Perplexity. Use a logged-out browser or a temporary chat so personalization and chat history do not color the result.
One run is a sample, not a verdict. Google's documentation explains why: AI Overviews and AI Mode may use a "query fan-out" technique, issuing multiple related searches across subtopics and data sources to build a response, and the set of responses and links varies by model and technique (Google Search Central). Run each prompt at least twice, on different days, before you call anything a pattern.
Step 2: Log Every Answer and Classify the Failure
Paste each answer into a spreadsheet verbatim. Record the date, engine, prompt, the exact wrong or missing claim, and any links the engine displayed. Mark whether your brand was only mentioned or actually cited, meaning the answer linked to or attributed a specific page. A mention without a citation can indicate that the engine recognizes your name as an entity but is not pulling from your content.
Then match each failure to a likely cause. This table is a starting hypothesis, not a diagnosis. Step 3 confirms it.
| What you see | Likely cause | Check first |
|---|---|---|
| Correct when asked directly, absent from category prompts | Weak category association | How your site and third-party profiles state your category |
| "No information," or confused with a similarly named company | Thin or ambiguous entity footprint | About page, structured data, name collisions |
| Old pricing, wrong location, retired product | Stale or conflicting source | Old pages, directories, press, review profiles |
| Described as the wrong type of company | Inconsistent descriptions across properties | Site, bios, and listings side by side |
| Competitors appear in comparisons where you do not | Context gap | Comparison pages and third-party roundups |
| Right on one engine, missing on another | Different sources or access per engine | Crawler access and engine-specific citations |
Look at the pattern across rows. If most of your failures cluster in one row, you have one root cause and one repair project, not a dozen separate problems.
Step 3: Trace the Wrong Claim to Its Source
Engines do not make claims in a vacuum. Some answers lean on what a model learned in training. Others retrieve live pages and cite them. Perplexity's developer documentation describes its Agent API as delivering "web-grounded answers with built-in citations" (Perplexity docs), which reflects the same retrieve-and-cite approach, though that page covers the API rather than the consumer app. OpenAI runs a dedicated crawler, OAI-SearchBot, to surface websites in ChatGPT's search features (OpenAI crawler documentation). When an answer shows sources, you have a trail to follow.
Work through the trail in this order:
- Open every source link the engine displays and read what that page actually says about you.
- Search the exact wrong phrase, in quotes, in a regular search engine.
- Search your own site for the claim, including old blog posts, archived pricing pages, press releases, and help articles.
- Check third-party profiles: business directories, app and software marketplaces, review sites, social bios, founder bios, and partner pages.
- Read the "alternatives to" and comparison pages that describe you, including competitors' pages.
Rank every source you find by how likely an engine is to trust it and how easy it is for you to change. In most cases, start with your own pages, then profiles you control, then press and partner pages you can ask to update. If an engine keeps citing one third-party page, move that page up the list, because it is plainly feeding the answer you are trying to correct.
If nothing matches, the claim likely comes from training data or from the model blending several vague descriptions into one. You cannot edit a model. What you can do is make current, accurate, consistent sources easy to find, so retrieval-based answers pick them up and future model updates start from better material.
Step 4: Rule Out Access and Indexing Problems
Before you rewrite anything, confirm that engines can actually read your correct pages. A flawless about page does nothing if the crawler never reaches it.
For Google's AI features, a page must be indexed and eligible to appear in Search with a snippet. According to Google's documentation at the time of writing, there are no additional technical requirements and no special schema.org markup needed to appear in AI Overviews or AI Mode (Google Search Central). The same page lists the basics worth verifying: crawling allowed in robots.txt and by any CDN or hosting layer, and important content available as text.
For ChatGPT, OpenAI documents that its robots.txt tags work independently. A site can allow OAI-SearchBot to appear in ChatGPT search while disallowing GPTBot, which governs training use. Sites opted out of OAI-SearchBot will not be shown in ChatGPT search answers, and OpenAI notes robots.txt changes can take about 24 hours to take effect for search (OpenAI crawler documentation). A configuration that surfaces you in search while declining training looks like this:
User-agent: OAI-SearchBot
Allow: /
User-agent: GPTBot
Disallow: /
Whether to allow GPTBot is a policy decision for your business. The point here is that a blanket block can silently remove your best pages from the evidence pool. OpenAI also lists ChatGPT-User, which visits pages when a person asks, and notes that robots.txt rules may not apply to those user-initiated visits.
Check your server logs and CDN settings for these common blockers, and prioritize fixing any you find:
- A blanket Disallow rule in robots.txt that covers search crawlers.
- A bot-protection or firewall rule at your CDN that rejects crawler requests.
- Key facts that sit behind a login wall or a form.
- Pages that render only through JavaScript, leaving no readable text for a crawler.
Step 5: Correct the Facts at the Source
Now you repair the sources from Step 3, starting with the ones you control. Do not expect to win by arguing with the engine. Change what it reads.
Write one canonical description
Draft a single plain-language description with your name, category, audience, main outcome, and one differentiator. Add a short fact sheet: current product and plan names, pricing model, locations, founding year, and anything that has changed in the last two years. A brand described three ways, say as a content platform, a scheduler, and a workflow assistant, gives an engine three partly true stories and no reason to pick one. Each description may be partly right, but when they disagree, the inconsistency creates ambiguity that no single page can resolve. One description, reused everywhere, removes it.
Fix your own pages first
Put the canonical description on your homepage, about page, and main product pages, and lead each page with the direct answer instead of a mission statement. Use the same product names in navigation, pricing, and help docs. Update or redirect stale pages that still state old facts, rather than leaving them live and contradicting the new ones.
Add Organization structured data as well. Google's documentation shows an Organization example with name, url, description, and sameAs properties pointing to your official profiles (Google Search Central). Keep the markup aligned with the visible text on the page, a point Google's AI features guidance also makes.
Correct third-party listings
Work down your ranked source list. Claim and edit directory and marketplace profiles. Update the boilerplate that partners, event pages, and review sites copy. For press coverage with a factual error, send the editor a short, specific correction request with the right fact and a link to your canonical page. Be polite and concrete. A request that names the sentence and the fix is easier for an editor to act on than a general complaint.
Fix the comparison context
If the engine places you beside the wrong competitors, look at who writes the comparisons. Publish a fair comparison page of your own that explains where you fit and where another option is the better choice. Specific, even-handed tradeoffs give an engine better material than a claim that you are simply different.
Step 6: When the Problem Is Omission, Not Error
Omission needs a slightly different repair. If an engine describes you correctly when asked directly but never surfaces you in category prompts, it has a comprehension gap: it can identify you, but it does not connect you to the problem a buyer is describing.
Aim for the smallest change that moves your test prompts. State your category and audience in plain words on the pages that matter most. Make sure your profiles use the same category language. Then earn a few accurate descriptions on sources your buyers and the engines already use, such as partner pages, relevant directories, and customer-approved stories. A handful of clear mentions beats a spray of generic ones.
Broad brand-authority building is a longer program than a repair. Keep this step narrow, and let your test results tell you whether more is needed.
Step 7: Re-Test, Then Monitor
Changes do not show up instantly. In its AI features guidance, Google notes that crawling can take anywhere from several days to several months, depending on how often its systems determine a page needs to be refreshed, and that you can request a recrawl after changes (Google Search Central). Give each fix a few weeks before you judge it.
Then rerun the identical prompt set on the same engines and log the results in the same spreadsheet. Compare against your baseline, not against your memory.
Call a fix real when three things hold:
- The wrong claim is absent across repeated runs over several weeks.
- The engine cites your canonical page or another source you corrected.
- The result holds on more than one engine.
After that, recheck monthly. A single answer proves little in either direction, so judge direction over a quarter. If a wrong claim returns, go back to Step 3, because a new source has usually appeared.
What You Cannot Control
No brand controls how an engine weighs its sources, and no tactic forces a model to say a specific thing. Fabricated reviews, prompt spam, and mass-produced pages add noise and erode the trust you are trying to rebuild. Avoid them.
For serious factual errors, also look for whatever feedback or report option each product offers, such as a thumbs-down control. The controls vary by product. Treat them as a supplement. The durable fix is accurate, consistent public evidence, because that is what every retrieval-based answer starts from.
Choosing How to Run This Over Time
You have three options for keeping the process going: a manual spreadsheet, a monitoring tool, or a periodic audit. A spreadsheet costs nothing and teaches you the most, but it depends on discipline. A monitoring tool saves effort, though it only helps if it tests the engines your buyers use, separates a bare mention from an attributed citation, lets you add your own prompts, and keeps history.
A periodic audit sits between the two. It gives you a baseline and a prioritized list of gaps without building the tracking yourself. BrandGhost's free discoverability audit scores representation across six areas: Website Representation, Search & AI Visibility, Authority & Trust, Audience Alignment, Content Coverage, and Conversion Readiness. That makes it a reasonable starting read if you want a baseline before you commit to a repair project.
Whichever route you choose, keep the logic of this guide. Name the failure, find the source, fix it where it lives, and test again. Engines repeat what the web tells them, so your job is to make the web tell one accurate story.