Branded vs Non-Branded GSC Reporting

Master the art of separating branded and non-branded search data in Google Search Console to unlock true organic growth insights and stop making decisions based on conflated metrics.

The Problem

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 completely 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, regular expressions, 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

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: regex \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): regex fusion|fusionio|fuzion|fusion|x Note: Include “x” only if it’s a legitimate short form. 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 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 the 1,000-query-limit issue 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 = [' 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 more than 20% 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 (50-80%). Non-branded CTR is lower (2-10%). 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 3-6 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. For example, if your non-branded clicks are growing 5% month-over-month, but a sudden spike to 15% 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 5-10% 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

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 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 >20% week-over-week
• Analyse top non-branded queries by impressions and clicks – identify content gaps
• Monitor branded average position monthly – if it rises above 2.0, investigate
• 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 (e.g., last 3 months).
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 \b(nike|nikecom|nike\.com|nike inc)\b → but this time select “Exclude” instead of “Include” (the toggle below the regex box). 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 the Google Sheets add-on “Search Analytics for Sheets” or schedule a GSC API query via Google Apps Script. The script can run every Monday and populate a pre-formatted report with the two segments.

Frequently Asked Questions

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” by adding negative lookaheads: \bapple\b(?! (pie|juice|sauce)). 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.

Can I use GSC’s “Query” filter for competitor brands?

Yes, you can create a separate filter for competitor branded queries (e.g., \b(mixpanel|amplitude)\b) and exclude them from your non-branded segment. This gives you a cleaner view of your own organic growth.

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. Also review for false positives (queries that match your brand regex but are not about your brand – e.g., if your brand is “Tide” and someone searches “tide pods” for the laundry detergent, but you are a software company called “Tide Analytics”).

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 v1 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.

Using NQZAI for This Playbook

NQZAI accelerates every step of this playbook by automating the manual data extraction, regex generation, and alerting. Instead of writing a Python script to fetch GSC data, you describe your brand variations in natural language and NQZAI outputs the correct regex pattern and a ready-to-use API query. It can also connect to your GSC account via OAuth, pull the last 16 months of query data, and automatically classify each query as branded or non-branded using machine learning (which catches misspellings and fuzzy matches you might miss). The results are pushed into a Looker Studio dashboard template that NQZAI generates for you. Weekly alerts for non-branded drops are set up as a one-click template. This reduces the entire playbook from a 3-day setup to a 30-minute configuration.