TL;DR

Separate branded and non-branded search data in Google Search Console using a regex-based filter you build once and reuse everywhere — mixing the two…

Separate branded and non-branded search data in Google Search Console using a regex-based filter you build once and reuse everywhere — mixing the two hides whether your growth is coming from brand awareness or genuine organic discovery.

Quick Answer

  • If you only look at total GSC clicks → split branded vs non-branded with a regex filter first, because a rising total can hide a stagnant or declining non-branded pipeline.
  • If you're not sure what counts as "branded" → treat any query containing a brand-name variation (including misspellings) as branded, because a fuzzy, feeling-based line produces inconsistent reports.
  • If your branded click share is climbing past 50% → investigate your non-branded content strategy, because that pattern often signals over-reliance on brand awareness rather than organic discovery.
  • If you need recurring reports → automate the pull with the Search Console API rather than re-filtering manually each week, because GSC's UI export doesn't scale to ongoing monitoring.
  • If you're hoping software will fully automate this segmentation → know that nqzai doesn't have a built-in branded/non-branded GSC classifier, because it's a content and outbound platform, not a Search Console analytics tool — you'll still build the regex and dashboard yourself.

The Problem

Direct answer: Most founders and SEO managers look at their Google Search Console (GSC) dashboard and see a single number for clicks, impressions, and average position. They celebrate when total clicks go up, but they have no idea whether that growth came from people already searching for their brand name or from new audiences discovering them through non-branded queries. The two channels behave differently: branded traffic is often a lagging indicator of brand awareness, while non-branded traffic is the engine of sustainable organic growth. Mixing them hides problems like a stagnant non-branded pipeline or a dangerous over-reliance on brand searches.

The core challenge is that GSC does not natively separate branded from non-branded queries. You have to build your own segmentation using regex filters and custom reports. Without a clean system, you end up with noisy data, false positives (e.g., a competitor's brand name that includes your brand), and missed opportunities to optimise your non-branded strategy. This playbook gives you a repeatable, data-driven framework to build that segmentation and report on it with confidence.

Core Framework

Direct answer: Define branded as any query containing at least one variation of your brand name (including common misspellings and abbreviations) — everything else is non-branded; build this list once and reuse it in every filter, dashboard, and API query.

Key Principle 1: Brand is a regex pattern, not a feeling

The boundary between branded and non-branded is fuzzy. "Nike" is branded, but "Nike Air Max" includes a product term. "Nike shoes" is a brand + product hybrid. The most reliable approach is to treat branded queries as any query that contains at least one of your brand's core name variations (including misspellings, abbreviations, and common typos). Everything else is non-branded. You define this set once and reuse it in every GSC filter, dashboard, and API query.

Example: For a brand called "Sparrow Analytics", the branded regex might be: sparrow|sparro|sparow|sprrow|sparrow analytics|sparrowanalytics|sparrow.ai

Key Principle 2: Separate the signal from the noise with a tiered filter

A single regex for all branded queries is too coarse. You need three tiers:

  • Pure branded – only the brand name (e.g., "sparrow")
  • Brand + product – brand followed by a product/category word (e.g., "sparrow pricing")
  • Brand + competitor – brand plus a competitor's brand (e.g., "sparrow vs mixpanel")

This tiering lets you understand whether branded queries are being used for navigational searches, purchase intent, or comparison shopping. Non-branded is everything else, including generic queries, long-tail, and competitor names without your brand.

Step-by-Step Execution

Step 1: Define your brand keyword universe

List every possible variation of your brand name that appears in actual search queries. Use GSC's query export (last 16 months) to find common misspellings and abbreviations. For a fast start, use a regex builder tool like Regex101 to test patterns.

Regex pattern for brand detection:

\b(brand1|brand1variant|brand2|brand2abbrev)\b

Replace brand1 with your actual brand term. Use \b word boundaries to avoid matching inside longer words (e.g., "sparrow" should not match "sparrowhawk").

Export the full query list from GSC (Performance report → Queries → Download). Filter for queries that contain your brand variations using a spreadsheet regex formula or a Python script. Create a final list of branded queries. All other queries become your non-branded set.

Step 2: Build a GSC regex filter for branded queries

In Google Search Console, go to the Performance report, click "+ New" under the filter bar, select "Query", then "Custom (regex)". Paste your branded regex pattern. Use the "contains" match type (case-insensitive is default). Name the filter "Branded Queries".

Example pattern for a brand called "Fusion" (with common misspellings):

fusion|fusionio|fuzion

Avoid overly broad patterns.

Create a second filter for "Non-Branded Queries" – you can either invert the branded filter or create a separate regex that excludes the brand pattern. Inverting is simpler: select "Branded Queries" filter, then click "Exclude" instead of "Include". GSC allows you to save multiple filters and toggle between them.

Step 3: Automate the export with the GSC API

Manual filtering is fine for one-off analysis, but for regular reporting you need automation. Use the Google Search Console API (v1) to pull data, then apply your regex client-side. This also lets you handle GSC's per-request row limit by paginating through all queries.

Python snippet to fetch queries and classify branded vs non-branded:

import re
from google.oauth2 import service_account
from googleapiclient.discovery import build

SCOPES = ['https://www.googleapis.com/auth/webmasters.readonly']
SERVICE_ACCOUNT_FILE = 'path/to/credentials.json'

credentials = service_account.Credentials.from_service_account_file(
    SERVICE_ACCOUNT_FILE, scopes=SCOPES)
service = build('searchconsole', 'v1', credentials=credentials)

site_url = 'https://www.example.com'
brand_pattern = re.compile(r'\b(sparrow|sparro|sparow)\b', re.IGNORECASE)

def classify_query(query):
    return 'branded' if brand_pattern.search(query) else 'non-branded'

# Fetch data (simplified – you need to handle pagination)
request = service.searchanalytics().query(
    siteUrl=site_url,
    body={
        'startDate': '2024-01-01',
        'endDate': '2024-12-31',
        'dimensions': ['query'],
        'rowLimit': 1000
    }
)
response = request.execute()
rows = response.get('rows', [])
for row in rows:
    query = row['keys'][0]
    category = classify_query(query)
    # Store in database or CSV

Step 4: Create a tiered dashboard (branded vs non-branded, plus sub-tiers)

Use Google Looker Studio (formerly Data Studio) or a BI tool to visualise the data. Connect your GSC data source (either via direct connector or through a BigQuery export). Add calculated fields to segment queries.

Example calculated field in Looker Studio:

CASE
  WHEN REGEXP_MATCH(Query, "\\b(sparrow|sparro|sparow)\\b") THEN "Branded"
  ELSE "Non-Branded"
END

Then create a time-series chart with two lines: branded clicks and non-branded clicks. Add a second chart for impressions and average position. Also create a table showing the top non-branded queries by clicks, so you can see which topics are driving real discovery.

Step 5: Set up weekly automated alerts for non-branded drops

The biggest risk is that non-branded traffic declines while branded traffic stays flat. Use Google Sheets + Apps Script or a scheduling tool to run a weekly check. If non-branded clicks drop sharply week-over-week, send an email alert.

Example alert logic:

# After fetching weekly data
if this_week_nonbranded_clicks < last_week_nonbranded_clicks * 0.8:
    send_alert(f"Non-branded clicks dropped {drop_percent}% this week")

Step 6: Analyse branded vs non-branded query patterns

Go beyond clicks. Compare:

  • Average position – branded queries often have lower position (closer to top) because Google knows the searcher wants your site. A drop in branded position signals a brand reputation issue.
  • Click-through rate (CTR) – branded CTR is usually high. Non-branded CTR is much lower. A sudden drop in branded CTR could mean competitors are showing in featured snippets or ads.
  • Page distribution – branded queries typically land on the homepage or branded pages. Non-branded queries should land on deep content pages. If branded queries are hitting non-branded pages, you have a site structure problem.

Step 7: Build a predictive model for non-branded growth

Once you have several months of clean segmented data, use a simple linear regression to forecast non-branded clicks based on historical trends. This helps you set realistic growth targets and identify anomalies early. If a sudden spike appears, check if it's from a news article or a viral post. If it's a drop, investigate algorithm updates or technical issues.

Common Mistakes

  • ❌ Using a single brand regex that is too broad – For example, if your brand is "Sun", the regex \bsun\b will match "sun protection", "sunlight", "sunny". Always add word boundaries and test against your actual query list.
  • ❌ Ignoring misspellings and abbreviations – Misspellings can account for a meaningful share of branded traffic. Without them, your branded segment is under-reported and your non-branded segment gets contaminated with navigational queries.
  • ❌ Treating "brand + product" as non-branded – A query like "Nike running shoes" is brand-driven, but many analysts lump it into non-branded because it's a product term. This inflates non-branded performance and makes it look like you're winning on generic terms when you're actually riding on brand awareness.
  • ❌ Not filtering out competitor brand terms – If you sell "Widget X" and a competitor is "Widget Y", a query like "Widget X vs Widget Y" is branded for you, but "Widget Y" alone is non-branded. Your regex must handle this. Use a separate exclusion list for competitor brands that you don't want to count as your own branded.
  • ❌ Relying on GSC's built-in query grouping – GSC's "Query" filter does not support case-insensitive regex properly in all views. Always test by exporting raw data and applying regex in a spreadsheet before trusting the filter.

Metrics to Track

Metric Definition Target Why It Matters
Branded Click Share Percentage of total clicks from branded queries Roughly 30–50% for established brands, lower for new brands If too high, you're over-reliant on brand; if too low, brand awareness is weak.
Non-Branded Impression Growth Month-over-month change in non-branded impressions Steady growth for a healthy content strategy Indicates whether your content is being discovered by new audiences.
Non-Branded CTR Average CTR for non-branded queries Varies by industry Low CTR suggests poor title tags or meta descriptions.
Branded Average Position Average position for branded queries Close to 1.0 A rising number means you're losing the first result to a competitor or a sitelink issue.
Branded vs Non-Branded Conversion Rate Conversion rate from each segment (if you have GA4 data) Branded typically higher than non-branded Non-branded conversion is a proxy for content quality and user intent matching.
Branded Query Volume Number of unique branded queries per month Growing (indicates expanding brand recall) Stagnation can mean your brand is not reaching new audiences.

Checklist

  • Export all GSC queries for the last 16 months (Performance report → Queries → Download)
  • Identify all brand name variations, misspellings, and abbreviations (use a spell-check tool and manual review)
  • Build a regex pattern and test it on a sample of 100 queries – check for false positives and false negatives
  • Create two GSC custom filters: "Branded" and "Non-Branded" (or use the invert feature)
  • Set up a weekly automated export using the GSC API (or a tool like Supermetrics)
  • Build a dashboard in Looker Studio with segmented time-series charts
  • Add a weekly alert for non-branded drops
  • Analyse top non-branded queries by impressions and clicks – identify content gaps
  • Monitor branded average position monthly
  • Share a monthly report with stakeholders that separates branded and non-branded growth

How to Build a Branded vs Non-Branded Report in GSC (Step-by-Step)

  1. Open Google Search Console → Performance tab → Search results.
  2. Click "+ New" under the filter bar → Query → Custom (regex).
  3. Paste your branded regex (e.g., \b(nike|nikecom|nike\.com|nike inc)\b). Do not use quotes around the regex.
  4. Name the filter "Branded Queries" and click Apply.
  5. View the report – this now shows only branded queries. Note the date range you want.
  6. Click "Download" → CSV to get branded data.
  7. Remove the filter → click the "X" next to the filter name.
  8. Create a new filter → Query → Custom (regex) → paste the same pattern → but this time select "Exclude" instead of "Include". Name it "Non-Branded Queries" and apply.
  9. View the non-branded report and download the CSV.
  10. Combine both CSVs in a spreadsheet, add a column "Segment" with values "Branded" or "Non-Branded", and create pivot tables for monthly trends.

For automated weekly reporting, use a Search Console Sheets add-on or schedule a GSC API query via Google Apps Script.

Frequently Asked Questions

Do I need special software to separate branded and non-branded traffic in GSC?

Direct answer: No — GSC's own custom regex filters, combined with a spreadsheet or a scheduled API pull, are enough to get accurate segmentation; dedicated software can save time at scale but isn't required.

What if my brand name is a common word (e.g., "Apple", "Amazon")?

Common words require careful handling. Use a combination of exact match plus additional context. For "Apple", add \bapple\b but also include \bapple inc\b, \bapple (store|iphone|mac)\b. Exclude queries like "apple pie" or "apple juice" with negative lookaheads where your regex engine supports them. This is complex – test thoroughly.

Should I include branded queries from my own subdomains (e.g., blog.example.com)?

Yes, because GSC tracks queries irrespective of the landing page URL. If someone searches "example blog" and lands on blog.example.com, that query is branded. The segment is about the query, not the page. If you want to separate by site section, use a separate dimension filter (e.g., page).

How do I handle brand names that are also product names (e.g., "Slack" for both the company and the software)?

Treat them as branded because the company is the primary owner. The search intent is almost always for the company's product. You can add a sub-segment for "brand + product" queries later.

What if my brand has multiple domains (e.g., example.com and example.co.uk)?

Each site must be tracked separately in GSC. You'll need to create filters for each site's property. If you want a unified view, export all site data and merge them in a spreadsheet or BI tool, applying the same regex across all sites.

How often should I update my brand regex?

At least every quarter. New misspellings appear, product names change, and your brand might acquire new abbreviations. Use the query export to find new variations and update the regex, and review for false positives along the way.

Using NQZAI for This Playbook

nqzai is a B2B outbound, lead-gen, and SEO/GEO content platform, priced on a pay-as-you-go, per-token basis with no subscription tiers. It does not have a built-in Google Search Console connector, a machine-learning branded/non-branded classifier, or a one-click Looker Studio template generator — those are not features nqzai currently ships.

Where a content-generation tool can genuinely help is on the writing side: drafting the technical documentation of your segmentation policy from this playbook, or turning your segmented data into a readable stakeholder report once you've already pulled the numbers.

Sources

  1. Google Search Central, Google Search Console Help – Official documentation on GSC reports, filters, and API.
  2. Moz, The Beginner's Guide to SEO – Foundational SEO concepts including branded vs non-branded.
  3. Ahrefs, How to Use Google Search Console for SEO – Practical guide to GSC data extraction.
  4. Google, Search Console API Documentation – Technical reference for automated data pulls.
  5. Search Engine Land, Guide to Google Search Console – Industry best practices for segmented reporting.
  6. Regex101, Online Regex Tester – Tool for building and validating regex patterns.