Track Brand Mentions Across Search Result Titles and Snippets

Manual brand searches do not scale.

If you care about brand visibility in search, checking whether your homepage ranks for your brand name is only the beginning.

For non-brand queries, you may want to know:

• does the brand appear in result titles?
• does it appear in snippets?
• does it appear in URLs?
• is the mention on your own domain or a third-party page?
• which query group produced the mention?
• did the context look positive, neutral, or unclear?

This post shows a small pattern for detecting brand mentions across search result titles, snippets, and URLs. A SERP API such as TalorData SERP API can collect structured results; the matching and review logic belongs in your code.

What counts as a brand mention?

Start with a clear definition.

A mention can appear in:

• title text
• snippet text
• visible URL or domain
• page URL path

You may also want to distinguish:

• owned mention: result is on your own domain
• third-party mention: result is on another domain
• brand-only mention: text contains only the brand name
• contextual mention: text mentions the brand with category, comparison, review, or use-case language

For a first version, keep it simple.

Example normalized result

Use a normalized shape so your matching code does not depend on raw provider fields:

{
  "query": "serp api alternatives",
  "location": "United States",
  "captured_at": "2026-07-21T09:00:00Z",
  "results": [
    {
      "position": 3,
      "title": "Example SERP API Alternatives Compared",
      "url": "https://example.com/blog/serp-api-alternatives",
      "snippet": "A comparison of tools for collecting search result data."
    }
  ]
}

The code below is generic. Replace field paths with the actual response schema from your SERP provider.

Define brand aliases

Brand matching should handle spelling, casing, and common variants.

BRAND_ALIASES = [
    "talordata",
    "talor data api",
    "talordata serp api",
]

OWNED_DOMAINS = {
    "talordata.com",
    "www.talordata.com",
}

Only include aliases you are comfortable tracking. Too many loose aliases can create false positives.

Normalize text before matching

import re
from urllib.parse import urlparse


def normalize_text(value: str) -> str:
    value = value.lower()
    value = re.sub(r"[^a-z0-9]+", " ", value)
    return re.sub(r"\s+", " ", value).strip()


def clean_domain(url: str) -> str:
    domain = urlparse(url).netloc.lower()
    if domain.startswith("www."):
        domain = domain[4:]
    return domain

Normalization keeps matching consistent across titles, snippets, and URLs.

Match title, snippet, and URL

def contains_brand(text: str, aliases: list[str]) -> bool:
    normalized = normalize_text(text)
    normalized_aliases = [normalize_text(alias) for alias in aliases]
    return any(alias in normalized for alias in normalized_aliases)


def inspect_result(result: dict, aliases: list[str]) -> dict:
    title = result.get("title", "")
    snippet = result.get("snippet", "")
    url = result.get("url", "")
    domain = clean_domain(url)

    title_match = contains_brand(title, aliases)
    snippet_match = contains_brand(snippet, aliases)
    url_match = contains_brand(url, aliases)
    owned_match = domain in OWNED_DOMAINS

    return {
        "position": result.get("position"),
        "title": title,
        "url": url,
        "domain": domain,
        "title_match": title_match,
        "snippet_match": snippet_match,
        "url_match": url_match,
        "owned_domain": owned_match,
        "any_brand_mention": title_match or snippet_match or url_match,
        "third_party_mention": (title_match or snippet_match or url_match) and not owned_match,
    }

The difference between owned_domain and third_party_mention is important.

Your own ranking page is useful. A third-party page that mentions the brand is a different signal.

Process a SERP snapshot

def inspect_serp(serp: dict) -> list[dict]:
    inspected = []

    for result in serp["results"][:10]:
        row = inspect_result(result, BRAND_ALIASES)
        row["query"] = serp["query"]
        row["location"] = serp.get("location")
        row["captured_at"] = serp.get("captured_at")
        inspected.append(row)

    return inspected

Now every result has a few fields you can aggregate later.

Create query-level metrics

def summarize_query(rows: list[dict]) -> dict:
    mentions = [row for row in rows if row["any_brand_mention"]]
    third_party = [row for row in rows if row["third_party_mention"]]
    owned = [row for row in rows if row["owned_domain"]]

    return {
        "query": rows[0]["query"] if rows else None,
        "brand_mentioned": bool(mentions),
        "owned_domain_visible": bool(owned),
        "third_party_mentions": len(third_party),
        "title_mentions": sum(1 for row in rows if row["title_match"]),
        "snippet_mentions": sum(1 for row in rows if row["snippet_match"]),
        "url_mentions": sum(1 for row in rows if row["url_match"]),
        "best_mention_position": min((row["position"] for row in mentions), default=None),
    }

This gives you a compact summary for dashboards or reports.

Add a review queue

Do not fully trust string matching.

Send these cases to review:

• third-party mentions on high-intent queries
• snippets that mention the brand but not the owned domain
• titles with comparison, alternative, review, or pricing language
• mentions where the URL is unknown
• sudden drops in owned-domain visibility
• sudden increases in third-party mentions

The review queue prevents the monitor from becoming a noisy keyword counter.

Store enough context

For each mention, store:

• query
• query group
• location
• capture date
• position
• title
• snippet
• URL
• domain
• owned or third-party flag
• matched field: title, snippet, or URL
• review status

This makes the result auditable.

Where the SERP API fits

The SERP API handles collection. Your code handles interpretation.

One useful workflow:

1. Collect SERP results for target queries
2. Normalize title, snippet, URL, domain, and position
3. Match brand aliases across fields
4. Separate owned results from third-party mentions
5. Queue sensitive results for review
6. Track changes over time

If you need structured search result data for this workflow, TalorData can support the SERP collection layer while your team defines the brand matching rules.

What not to over-automate

I would avoid automatically labeling mention quality from a short snippet alone.

A snippet may be truncated. A title may be ambiguous. A third-party page may mention the brand in a list, a comparison, a complaint, or a tutorial.

Use the monitor to find the places worth reading, not to make every judgment automatically.

Final thought

Brand visibility in search is more than whether your own domain ranks.

Titles, snippets, URLs, and third-party pages can all shape what searchers see. A small mention monitor can help you notice those signals before they disappear into manual search checks.

If you track brand mentions in SERPs, I would be curious which matching rules helped reduce false positives.