How to Get Recommended by ChatGPT: A 6-Step Playbook

Getting named by ChatGPT is not luck and it is not a hack. It is a mechanical sequence: a decision to search, a fetch, an extraction, a ranking, and a citation, each step with its own failure points. Here is the six-step loop that builds momentum across every engine, followed by the mechanism-level detail of how ChatGPT specifically decides what to fetch, what to trust, and whose name it says out loud.

Step 1: Pick the money queries

Start with the decision most people skip: choose the exact questions you want to win, phrased the way a buyer would actually ask an AI. "Be more visible" is a wish. "Be named when someone asks ChatGPT who is the best fractional CFO for early-stage SaaS" is a testable event with a yes or no answer. These queries become your scoreboard, and everything downstream aims at them.

Step 2: Build the knowledge base

Now feed the Knowledge signal on purpose. Publish deep, specific, original work engines can attribute to one named human, in enough volume that it reads as a body. Publish positions, not summaries. Not "what is personal branding," a question any machine can answer, but the opinionated take only you can hold because of what you have done.

Step 3: Manufacture the network signal

This is the step most people underbuild and the one that carries the most weight. Engineer third-party references, because engines trust what others say about you more than what you say about yourself. A journalist quoting you, a podcast hosting you, a respected list naming you, a peer citing your work. Your carefully worded homepage is table stakes, not evidence.

Step 4: Structure for machines

You have built real signals. Now make sure machines can read them and attribute them all to one unambiguous identity. Most professionals accidentally exist as several different people online: one name here, an abbreviated name there, a different title, an old bio that contradicts the new one. To a human these obviously refer to one person. To an engine building an entity, that fragmentation is fatal, because a signal it cannot attribute is a signal that does not count.

Step 5: Lift authority

Raise the ambient authority of your identity and your web properties to the level your niche requires to be named. Knowledge, network and clean structure get you into contention. Authority is the overall weight that tips contention into selection: the strength of your properties, the quality and quantity of references pointing at you, the consistency and age of your entity, and the company you keep in the web's citation graph.

Step 6: Track and re-run

PEO is a loop, not a launch. Re-ask your money queries on each engine, record whether you are named, find the gaps, and run the method again where you fall short. Without measurement, PEO is faith. With it, PEO is a discipline. There is no day you finish, only a loop you run, measure, and re-run until the engine says your name.

Putting it in order

Define and baseline first, then build knowledge, then network, keeping structure clean throughout, then lift authority, then measure and repeat. Start narrow, on one question that pays, and widen only once you win it. That loop is engine-agnostic. What follows is specific to ChatGPT: how it decides to go get a live source instead of relying on what it already knows, and what has to be true about your pages for that fetch to end with your name.

How ChatGPT decides whether to answer from memory or go get a source

ChatGPT is not a single mechanism you optimize for once. It is two systems stacked on top of each other. The first is parametric memory: statistical patterns absorbed during training, baked into the model's weights, frozen as of a training cutoff. The second is a separate browsing and retrieval layer that can search the live web mid-conversation, fetch pages, and quote them. Which one answers a given question depends on signals in the prompt, not on a fixed rule you can read in a spec. We unpack the full split between these two doors into an answer in Training Data vs Retrieval: The Two Doors Into an AI Answer, but the short version for this playbook is that recommendation-style prompts, "who is the best," "who should I hire," "who is a leading voice in," almost always tip toward the live path, because they demand a current, comparative judgment a frozen snapshot cannot responsibly supply on its own.

You can see the fingerprints of this split in your own server logs. OpenAI operates distinct fetch agents for distinct jobs: GPTBot crawls broadly to gather training data for future models, OAI-SearchBot crawls to build the index that live browsing draws from, and ChatGPT-User fetches a specific page in direct response to something a user typed in a live conversation. Each one can be allowed or blocked independently in robots.txt, which means a site can accidentally welcome the training crawler while blocking the exact agent that would have fetched it for a real-time recommendation. The full breakdown of what each agent does, and how to address each one individually, is in the AI crawler directory.

Why this distinction matters for a recommendation query specifically

If your name and work exist heavily in whatever data trained the model, but nothing about you is currently fetchable on the live web, you are betting entirely on parametric memory holding an accurate, un-hedged fact about you, which is a weaker bet than it sounds, because training data ages and models default to caution about specific, high-stakes claims involving a named person. If instead your site is thin on training-era presence but clean, current, and fetchable right now, the live path can still surface you, because the browsing tool does not care how long you have been known. It cares whether a fetch this minute returns a clear, attributable answer. The two paths are not competitors, they are both worth feeding, but for anyone starting today, the live-fetchable path is the one you can influence on a timeline measured in days rather than the years it takes to shift what a future model absorbs in training.

Inside the browsing tool: fetch, extract, chunk, rank

When ChatGPT decides to go live, the process is not "read the page." It is a short pipeline, and a break at any stage means your content never reaches the part of the system that writes the final answer. First, a search step rewrites the user's question into one or more queries and returns a list of candidate URLs. Second, a fetch step retrieves each candidate page. Third, an extraction step strips navigation, scripts, cookie banners, and layout chrome to isolate the page's actual content. Fourth, a chunking step breaks that content into passages small enough to reason over. Fifth, a ranking step scores those passages against the original question. Only then does a composition step synthesize an answer, selecting which passages, and which named sources, get quoted or cited. The chunking and ranking stages are where most well-intentioned content quietly fails, and the mechanics of writing for that specific stage are covered in chunk theory and passage-level optimization.

What "answer-shaped" means at the passage level

• A single declarative sentence that states who did what, without requiring the paragraph before or after it to complete the thought.
• A heading that mirrors the phrasing a buyer would actually type, not a clever headline that reads well to a human but signals nothing to an extractor scanning for topical relevance.
• One idea per paragraph, so a chunk boundary falling in the middle of your page still leaves each resulting piece internally coherent.
• The load-bearing fact stated early in the sentence, not buried behind three qualifying clauses a passage-ranking pass may never reach.

The full method for writing prose that survives this exact pipeline, rather than prose that merely reads well, is the subject of answer-shaped writing.

The three checkpoints a page must clear before ChatGPT can cite it

Strip away the jargon and there are only three gates a page has to pass, in order, before it can become the source ChatGPT names in an answer. Fail any one and the rest of your content strategy is irrelevant to this specific engine.

The three checkpoints a page must pass, in order, before ChatGPT can turn a fetched page into a named citation.

The crawlable checkpoint is the one people get wrong by accident rather than by choice. A generic "disallow all bots except the ones I recognize" line, copied from a boilerplate template years ago, can quietly block ChatGPT-User while leaving GPTBot untouched, which means you are training-data-visible but invisible to the exact agent that answers a live recommendation question. A minimal, explicit allow list removes the ambiguity:

User-agent: OAI-SearchBot
Allow: /

User-agent: ChatGPT-User
Allow: /

User-agent: GPTBot
Allow: /

Sitemap: https://yoursite.com/sitemap.xml

A robots.txt that explicitly allows all three of OpenAI's named agents, rather than leaving the outcome to whatever a default template happened to include.

A worked walkthrough: tracing one query end to end

Imagine a consultant named Jordan Ames who wants to be the name ChatGPT returns for "who is a good fractional CFO for an early-stage SaaS company." A user types roughly that question. ChatGPT judges it a live, comparative, current question and triggers the browsing path rather than answering purely from memory. The search step rewrites the query and returns a handful of candidate pages: a general directory listing dozens of CFOs, a competitor's personal site, and Jordan's own about page. The fetch step retrieves all of them. The extraction step then does the sorting a human would not see: the directory page yields a wall of names with almost no attributable detail per person, so it extracts poorly. The competitor's site is a heavy JavaScript application that renders content client-side, so the fetch returns a near-empty shell. Jordan's about page, written in plain server-rendered HTML with declarative sentences stating role, track record, and specialization, extracts cleanly into several strong, self-contained passages.

The ranking step then scores those passages against the query, and Jordan's clean, specific, answer-shaped passages about SaaS-stage CFO work outrank the directory's thin listing and the competitor's empty shell, not because Jordan is more accomplished, but because Jordan's page is the only one that survived extraction intact. The composition step drafts an answer, and because Jordan's site also carries Person schema with a consistent name and a sameAs link to a matching LinkedIn profile, the composer can confidently attribute the passage to one named human rather than hedge with something vague like "one CFO mentioned online." Jordan gets named. The lesson generalizes: winning this query was not about being the best CFO in the directory, it was about being the only page in the candidate set that cleared all three checkpoints at once.

Markup and identity signals that tip the citation in your favor

Once a page is crawlable and extractable, the deciding factor in a close call is almost always attribution confidence, and that is a markup problem more than a writing problem. A Person schema block in JSON-LD gives the composer an explicit, structured statement of who you are, what you do, and how your profiles connect, instead of forcing it to infer identity from prose alone. The single highest-leverage property inside that block is the one most sites omit, covered in full in sameAs: the most underrated line in your markup, because it is the line that lets an engine merge your about page, your LinkedIn, and your published work into one entity instead of three uncertain fragments. The underlying discipline that makes all of this hold together across every page you control, one name, one title, one bio, is the subject of Structure Your Identity for Machines, and it is worth doing before you write another word of content aimed at this specific engine, because clean identity is what lets a strong passage actually get credited to you rather than cited as an anonymous fragment of the internet.