Most teams treat the <title> element as the thing that appears in search results. It isn't. It's one input into the title link Google generates, and Google substitutes something else often enough that your carefully written titles may never be seen by a searcher.
Worse, Search Console won't tell you. It reports clicks, impressions, and position for query–page pairs, but it contains no field for what text Google actually displayed. If you want to know your rewrite rate, you have to measure it yourself — and the measurement has enough traps that a sloppy version will tell you rewrites are rare when they aren't.
Why Google generates a title link instead of using yours
Google's documentation on title links states that it uses the content of the <title> element as the primary source but may use other text on the page when the title element is a poor description of the content. It lists candidate sources explicitly: the title element, main visible headings (including <h1>), other prominent text via size and styling, other on-page text, anchor text pointing at the page, and text in links on the page.
The mechanism matters for two reasons. First, a rewrite isn't random — it's a substitution from a bounded set of candidates on or pointing to your page, which makes it predictable. Second, Google has said the title link is generally consistent across queries for a given page, unlike snippets, which are assembled per query. That's what makes rewrite measurement tractable at all: one observation per URL is usually enough, whereas snippet measurement would require one per query.
One caveat that trips people up: Google works from the rendered document. If a JavaScript framework sets document.title after hydration, that's the title Google sees. If your HTML ships a placeholder and your app patches it later, you're measuring the wrong string in your crawler.
The rewrite patterns you can actually predict
In practice, the substitutions cluster. Before building anything, know what you're classifying:
| Pattern | What Google displays | Likely trigger | |
|---|---|---|---|
| Brand suffix removed | Title minus ` \ | Brand` | Length pressure, or brand repeated in the visible page |
| Brand suffix added | Your title plus site name | Site name available and title lacks it | |
| H1 substituted | Text of the main heading | Title element is boilerplate or mismatched to content | |
| Half-title | First clause only | Long title, pipe/dash-delimited keyword stacking | |
| Breadcrumb-style | Category – Subcategory | Templated titles that are near-duplicates sitewide | |
| Truncation with ellipsis | Prefix of your title | Pure pixel-width limit, not a rewrite |
That last row is the most common measurement error. Truncation is a display limit and depends on device and pixel width, not character count. If you count truncated titles as rewrites, your rate will be inflated and your fixes will be aimed at the wrong problem.
How to measure your rewrite rate without fooling yourself
The method is a join between two datasets you have to collect separately: your rendered titles, and the titles Google displays.
- Sample deliberately. Pull your top URLs by impressions from Search Console, then stratify — take a fixed number of URLs from each major template (product, category, article, hub). Sitewide averages hide the fact that one template has a 90% rewrite rate.
- Get the rendered title. Crawl with JavaScript execution and store the title from the DOM, not the raw HTML. Store the
<h1>, the first visible heading, and the site name from your markup too — you'll need them as candidate sources. - Capture the displayed title. Query a SERP source with a fixed locale and device profile, using a query that reliably surfaces the URL. A
site:-scoped or brand-plus-exact-title query is fine for this purpose — you're identifying a document, not testing its ranking. - Normalize before comparing. Lowercase, collapse whitespace, decode HTML entities, normalize dash and quote variants, and strip trailing ellipses.
- Classify, don't just diff. An exact-match test throws away all the diagnostic value.
def classify(shown, title, h1, brand):
if shown == title:
return "exact"
if title.startswith(shown.rstrip(" .…")):
return "truncated" # display limit, not a rewrite
if shown == strip_suffix(title, brand):
return "brand_removed"
if shown == f"{title} - {brand}":
return "brand_added"
if token_set_ratio(shown, h1) > 90:
return "h1_substituted"
return "other_source"Use a token-set similarity score rather than equality for the heading comparison; Google frequently reflows punctuation. Anything landing in other_source deserves manual review — that bucket is where you'll find anchor text and body copy being promoted, and where the genuinely surprising cases live.
Publicly reported rates give you a sense of scale: Zyppy's large-scale 2021 analysis of title rewrites, published after Google's title-link update, found that Google changed the majority of the titles it examined. Treat that as an order-of-magnitude expectation, not a benchmark — your rate depends almost entirely on how templated your titles are.
Does a rewrite cost you clicks?
This is where the analysis usually goes wrong. Comparing average CTR for rewritten versus unmodified URLs confounds three things: position, query mix, and the reason for the rewrite.
Rewrites are not assigned at random. Google rewrites when it judges your title a poor description — so rewritten pages are systematically different from non-rewritten ones. Any raw CTR gap is an association, not an effect.
A more defensible read:
- Compare within narrow position bands (say, 2.5–3.5 average position) and within a single template, so query mix and ranking are roughly held constant.
- Compare against your own CTR curve rather than a published one, then look at residuals — actual CTR minus expected CTR at that position — split by rewrite class.
- Treat the substituted text as the finding. If Google is showing your
<h1>instead of your title, the actionable information is that Google considers the H1 a better description. That's a content signal regardless of what CTR says.
The only clean causal test is to change titles on a randomized set of URLs and measure, which puts you back in split-test territory with all its usual constraints around sample size and time.
What to do with the results
- Re-measure per template after any title change. A sitewide rate is a vanity metric; template-level rates tell you which pattern to fix.
- Fix the triggers before rewriting the copy: drop keyword stacking with multiple delimiters, stop repeating the brand in both title and visible header, and make templated titles differ in more than one token.
- If Google consistently swaps in your H1, either adopt the H1's framing in the title or accept the substitution — fighting it by lengthening the title usually produces a half-title instead.
- Separate the truncation bucket and solve it with pixel-width budgeting, front-loading the distinguishing words, not with rewrites.
- Store every observation with a timestamp. Rewrite behavior shifts with Google's updates, and a single snapshot can't distinguish "we fixed it" from "Google changed its mind."