---
title: "Regex cheatsheet for marketers: Search Console, GA4, Sheets and more"
description: "A plain-words regex cheatsheet for marketers: tested copy-paste patterns for Search Console, GA4, Looker Studio, Sheets, Google Ads and Screaming Frog."
url: https://dumbcmo.com/blog/regex-cheatsheet-for-marketers
category: "Knowing what works"
tags: ["how-to", "regex", "search console", "ga4", "looker studio", "google sheets", "google ads", "screaming frog", "analytics", "seo"]
published: 2026-11-08
updated: 2026-11-08
reading_time: 18 min
author: "The DumbCMO"
---

# Regex cheatsheet for marketers: Search Console, GA4, Sheets and more

> **TL;DR:** Regex is a tiny pattern language for saying “show me rows like this”. Learn about 12 symbols and you can split brand vs non-brand searches, find question queries and group pages. Watch the rules: Search Console matches partly and ignores case. GA4 must match the whole value.

[Notebook](https://dumbcmo.com) › [Blog](https://dumbcmo.com/blog) › Knowing what works › Regex cheatsheet for marketers: Search Console, GA4, Sheets and more

Here’s a secret that should make you feel better. Developers, the people who write code all day, still find regex a b#tch. They google it. They copy it off Stack Overflow. They test it three times and it still breaks on a Friday.

So if regex looks like a cat walked across your keyboard, you’re in good company.

The good news: marketers need about a dozen symbols, not the whole language. This note gives you those symbols in plain words, then copy-paste patterns for the tools you already open every week. I tested every pattern in this note (how is at the bottom).

## In normal-people words

## What regex is, in plain words

Regex (Short for “regular expression”. A short pattern that describes what some text should look like, so a tool can find every row that fits.) is a way of saying “show me everything that looks like *this*” instead of typing every item one by one.

Instead of filtering Search Console 15 times for “how”, “what”, “why”… you filter once with one pattern.

## Why a marketer should care

- **Brand vs non-brand.** See how much of your Google traffic is people who already know your name, and how much is new people finding you. That’s the real test of SEO.
- **Questions people ask.** Pull every “how / what / can I” search in one go. That’s your content list.
- **Group pages.** Blog vs product vs category pages, in one filter.
- **Clean messy data.** Strip UTM tags from URLs, pull domains out of links, tag keywords in a spreadsheet.
- **Wasted ad money.** Spot search terms with “free”, “jobs” or “course” in them that you’re paying for.

> **The DumbCMO:** You don’t need to love regex. You need about 12 symbols and the discipline to test before you trust.

## The cheatsheet: the symbols marketers actually need

Our example business: **Anita’s Bakes**, a home bakery in Pune. Every example uses her searches and URLs.

- `.` **any one character.** `m.n` matches “man” and “men”. Careful: a plain dot in `example.com` also matches “examplexcom”. Write `example\.com` for a real dot.
- `*` **the thing before me, zero or more times.** `.*` means “anything at all, or nothing”. The marketer’s duct tape.
- `+` **the thing before me, one or more times.** `\s+` means “one or more spaces”.
- `?` **the thing before me is optional.** `anitas?` matches “anita” and “anitas”. `https?` matches http and https.
- `|` **or.** `cake|cupcake|brownie` matches any of the three.
- `^` **starts with.** `^how` matches “how to store cake” but not “cake how to”.
- `$` **ends with.** `/blog/$` matches the blog home page only, not every post under it.
- `( )` **a group.** Keeps an “or” together: `^(how|why)` means “starts with how, or starts with why”. In extract functions, the group is the bit you get back.
- `[ ]` **one of these characters.** `colou?r` is fine, but `[0-9]` means any one digit and `[aeiou]` any one vowel. `[^/]` means “any character except a slash”.
- `\` **take the next symbol literally.** `\.` is a real dot. `\?` is a real question mark (handy for URLs with parameters).
- `{n}` or `{n,}` **exactly n times, or n or more.** `\d{6}` matches a six-digit Indian PIN code. `(\S+\s+){4,}` means “at least four words followed by spaces”.
- `(?i)` **ignore upper or lower case.** Put it at the very start. Needed in tools that are case-sensitive (GA4, Looker Studio, Sheets, Google Ads scripts). Search Console already ignores case.

Two bonus shorthands Google lists for Search Console: `\d` is any digit, `\s` is any space, and `\S` is anything that isn’t a space.

## The chai stall version

Regex is the chai-wallah’s shorthand. He doesn’t write “one cutting chai with less sugar, one with extra ginger”. He writes “2C, 1 -S, 1 +G”.

Same order. Ten times faster. **Gibberish to everyone who hasn’t been told the code.** Now you’ve been told.

## Before Search Console: the four rules Google spells out

From Google’s own [Search Console help page on filtering](https://support.google.com/webmasters/answer/17011165):

1. **It uses RE2 syntax.** That’s Google’s own regex flavour. It’s fast and safe, and it skips some fancy features.
2. **It matches partly by default.** `cake` finds any query *containing* “cake”, unless you use `^` or `$`.
3. **It ignores case by default.** “Cake” and “cake” are the same. If you want case to matter (for URLs, say), start with `(?-i)`.
4. **Regex only works on Queries and Pages.** Choose **+ Add filter → Queries or Pages → Custom (regex)**, then pick **Matches regex** or **Doesn’t match regex**.

What RE2 *doesn’t* do: lookaheads and lookbehinds, the `(?!…)` and `(?<=…)` tricks you’ll see in developer forums. Search Console won’t run them. Use **Doesn’t match regex** instead of “not followed by” tricks.

The length limit: Google’s Daniel Waisberg has said the filter takes up to **4,096 characters**, as reported by [Search Engine Land](https://searchengineland.com/google-search-console-api-regex-389034). I couldn’t find that number on the current help page itself, so treat it as “Google said it”, not “it’s in the docs”. You’ll rarely hit it unless your brand has 300 misspellings.

> **The DumbCMO:** Search Console won’t warn you if your regex is wrong. It just shows zero rows. Very calm. Very unhelpful.

That zero-rows habit comes from practitioner guides, not Google’s docs. In practice: if a filter shows nothing, check your pattern before you panic about traffic.

## Search Console: query filters you can paste today

Go to **Performance → Search results → + Add filter → Query → Custom (regex)**.

### 1. Branded searches (with typos)

```
an(i|ee)th?a'?s?\s?bakes?
```

Matches “anita’s bakes”, “anitas bake”, “aneeta bakes”, “anitha bakes”, “anitabakes”. Doesn’t match “anita lewis” or “bakes near me”.

How to build yours: write your brand, then make the bits people get wrong optional with `?`, and the bits they swap into a group with `|`. Look at your real query list for typos first. Don’t guess.

### 2. Non-branded: everyone who doesn’t know you yet

Same pattern, but choose **Doesn’t match regex**. This is the number your SEO person should be proud of. Branded clicks mostly come from your reputation, ads and word of mouth, not SEO.

### 3. Question searches

```
^(who|what|when|where|why|how|which|can|does|do|is|are|should|will)\b
```

The `\b` means “end of a word”, so “island cake” doesn’t sneak in as “is”. Matches “how long does fondant last” and “can I freeze cake”. Every row is a question you could answer on your site.

### 4. Long-tail searches (five words or more)

```
^(\S+\s+){4,}\S+$
```

In plain words: four or more “word + space” chunks, then one last word. “eggless chocolate cake delivery in pune” is in. “custom cakes pune” is out. Long searches tend to be specific, and specific usually means closer to buying.

### 5. Commercial intent: people comparing before they buy

```
\b(best|top|vs|versus|reviews?|price|pricing|cost|cheap|alternatives?|compare)\b
```

The `\b` on both sides stops “bestow” and “costume” from matching. These searches deserve a clear prices page and an honest comparison page.

### 6. Local searches

```
near me|nearby|\b(pune|mumbai|bengaluru|bangalore|indiranagar)\b
```

Swap in your cities and neighbourhoods. If this list is big, your [Google Business Profile](/blog/google-business-profile) deserves more love than your blog.

### 7. Exclude your brand from any of these

Search Console allows one regex per filter, but you can stack filters. So: **Query → Custom (regex) → Matches** the question pattern, then add a second **Query → Custom (regex) → Doesn’t match** the brand pattern. That gives you non-branded questions only.

## Search Console: page filters

Choose **+ Add filter → Page → Custom (regex)**.

**Only the blog:**

```
/blog/
```

**Several sections at once:**

```
/(blog|guides|case-studies)/
```

**URLs with any parameters** (`?sort=`, `?utm_`…):

```
\?
```

**URLs with UTM tags specifically** (these shouldn’t usually show up in Google; if they do, ask your developer about canonical tags):

```
[?&]utm_
```

**A slug pattern:** blog posts with price or cost in the slug, but not the pages under them:

```
/blog/[^/?#]*(price|pricing|cost)[^/?#]*$
```

**Just the home page:**

```
^https://example\.com/$
```

Replace `example\.com` with your domain and keep the backslash before the dot.

**Case-sensitive URL check** (finds “/Blog/” but not “/blog/”, useful for spotting duplicate URLs):

```
(?-i)/Blog/
```

### Comparing sections

The easy way: apply `/blog/`, write down clicks and CTR. Then change it to `/products/` and write those down. Compare the two. If blog pages get impressions but almost no clicks, the AI box at the top is probably answering those questions. We covered that in [DataForSEO’s Search Insider 2026](/blog/dataforseo-search-insider-2026) and [SEO in the age of AI answers](/blog/seo-in-the-age-of-ai-answers).

> **The DumbCMO:** Brand vs non-brand is the most useful regex in marketing. Also the one most agency reports quietly skip.

## GA4: the full-match trap

Google’s [GA4 regex help page](https://support.google.com/analytics/answer/1034324) says two things that bite everyone:

- **GA4 regex is “full regex” by default.** The pattern must match the *whole* value. `blog` does **not** match `/blog/how-to-store-cake`. You need `.*blog.*`.
- **It’s case-sensitive.** “Instagram” and “instagram” are different values.

Google says GA4 supports regex in data filters, key events, segments, audiences, content groups and custom channel groups.

Where you’ll actually use it:

- **Explorations** (Explore → Free form → Filters): the “matches regex” option works on data you already have. Page path matches `.*/blog/.*` gives you blog pages only.
- **Audiences and segments:** conditions like page path matches `.*/(pricing|checkout)/.*` for “people who looked at prices”.
- **Comparisons in standard reports:** I couldn’t confirm regex there. A GA4 community answer says comparisons only offer exact and “contains” matching. The usual workaround is to build an audience with your regex, then compare by audience name.
- **Custom channel groups:** a useful one in 2026 is grouping AI assistant traffic. Session source matches:

```
.*(chatgpt|perplexity|gemini|copilot|claude).*
```

That catches “chatgpt.com”, “perplexity.ai”, “gemini.google.com” and so on. Some GA4 menus also offer a “partially matches regex” option, which behaves like “contains”. Practitioner guides say you’ll find it in places like channel groups. Check which one your menu shows, and add `.*` on both ends when it only says “matches regex”.

For case, `(?i)` at the start is RE2 syntax and is the standard way to ignore case, e.g. `(?i).*(facebook|instagram).*`. Test it on your own data in an Exploration first.

## Looker Studio: calculated fields

Looker Studio [uses RE2](https://support.google.com/looker-studio/answer/10496674), is case-sensitive by default and accepts `(?i)`. The trap: **REGEXP_MATCH matches the whole value** ([Google’s docs](https://cloud.google.com/looker/docs/studio/regexpmatch)). If you want “contains”, use REGEXP_CONTAINS or wrap your pattern in `.*`. Google also suggests raw strings, `R"..."`, so backslashes behave.

**Branded vs non-branded column** for a Search Console data source:

```
CASE
  WHEN REGEXP_MATCH(Query, R"(?i).*an(i|ee)th?a'?s?\s?bakes?.*") THEN "Branded"
  ELSE "Non-branded"
END
```

**Pull the first folder out of a URL** (`/blog/how-to-store-cake` becomes `blog`):

```
REGEXP_EXTRACT(Landing Page, R"^/([^/]+)/")
```

**Drop everything after the question mark** so `/cakes?utm_source=ig` and `/cakes` count as one page:

```
REGEXP_REPLACE(Landing Page, R"\?.*$", "")
```

## Google Sheets: cleaning and tagging

Sheets [uses RE2 too](https://support.google.com/docs/answer/3098292) (except Unicode character classes), and is case-sensitive. The three functions:

**Strip UTMs and other parameters:**

```
=REGEXREPLACE(A2, "\?.*$", "")
```

**Pull the domain out of a URL** (`https://www.theobroma.in/cakes?x=1` becomes `theobroma.in`):

```
=REGEXEXTRACT(A2, "^(?:https?://)?(?:www\.)?([^/:?#]+)")
```

**Grab the utm_source value:**

```
=REGEXEXTRACT(A2, "[?&]utm_source=([^&#]+)")
```

**Tag keywords from a Search Console export:**

```
=IF(REGEXMATCH(LOWER(A2), "\b(best|vs|reviews?|price|cheap|alternatives?)\b"), "Commercial", "Other")
```

`LOWER()` takes care of case, so you don’t need `(?i)`. REGEXEXTRACT gives you back whatever is inside the brackets.

## Google Ads: negatives, scripts and the honest limits

What I could verify:

- **Google Ads scripts and the Google Ads API (GAQL) support `REGEXP_MATCH`**, using RE2 syntax. Google’s [GAQL grammar page](https://developers.google.com/google-ads/api/docs/query/grammar) lists it, and its [case-sensitivity page](https://developers.google.com/google-ads/api/docs/query/case-sensitivity) covers case. Matching is case-sensitive, so use `(?i)`. Example condition: `campaign.name REGEXP_MATCH "(?i).*brand.*"`.
- **The Search terms report screen itself:** I couldn’t find Google documentation for a regex filter there. So don’t count on one.

The practical negative-keyword routine, no code needed:

1. Export the search terms report to Google Sheets.
2. In a new column, flag the time-wasters:

```
=REGEXMATCH(LOWER(A2), "\b(free|jobs?|salary|course|classes|recipe|diy|template|internship)\b")
```

3. Sort by cost. Every TRUE row with spend and no conversions is a negative keyword candidate. “Recipe” is a big one for a bakery: those people want to bake, not buy.

Remember negative keywords themselves are words, not regex. Regex only helps you *find* them. More on the basics in [Google Ads for beginners](/blog/google-ads-for-beginners).

> **The DumbCMO:** Paying for “free cake recipe” clicks for six months because nobody filtered the search terms. That’s the expensive kind of not knowing regex.

## Screaming Frog: crawl less, extract more

From Screaming Frog’s [custom extraction guide](https://www.screamingfrog.co.uk/guides/custom-extraction/) and [web scraping tutorial](https://www.screamingfrog.co.uk/seo-spider/tutorials/web-scraping/):

- **Include and Exclude** (Configuration → Include / Exclude) take regex against the URL. Their examples use `.*` patterns like `https://www.example.com/blog/.*`. Crawl only the blog, or skip `/p/` product pages on a huge shop.
- **Custom extraction** (Configuration → Custom → Custom Extraction) offers XPath, CSS Path and regex. Screaming Frog says to use regex for things that aren’t HTML elements, like JSON-LD structured data or inline scripts. Up to 100 extractors.
- Its regex engine treats `.` as matching new lines too. Screaming Frog isn’t RE2, so don’t assume a pattern that works there will work in Search Console, or the other way round.

Two extraction patterns I tested:

**Schema type from JSON-LD:**

```
"@type"\s*:\s*"([^"]+)"
```

**Google Tag Manager container ID:**

```
["'](GTM-[A-Z0-9]+)["']
```

## Google Tag Manager, briefly

GTM triggers offer **matches RegEx** and **matches RegEx (ignore case)** as conditions, e.g. fire a tag when Page Path matches `^/(thank-you|order-confirmed)`. Guides disagree on whether GTM matches the whole value or just part of it. So test every trigger in **Preview** mode before you publish the container.

## Common mistakes (I’ve made all of them)

**Why your regex isn’t working**

- **If** You wrote example.com with a plain dot **→ then** The dot means “any character”. It works by luck. Write it with a backslash before the dot.
- **If** It works in Search Console but not GA4 **→ then** GA4 wants the whole value to match. Put .* at both ends.
- **If** Capital letters slip through or go missing **→ then** GA4, Looker Studio, Sheets and Google Ads scripts care about case. Add (?i) at the start, or LOWER() in Sheets. Search Console doesn’t care.
- **If** Your “starts with how or why” filter matches random stuff **→ then** Without brackets, the “or” splits the whole pattern. The start-of-line symbol only sticks to “how”. Wrap the options in brackets after the ^.
- **If** Your extraction grabs half the page **→ then** .* is greedy: it grabs as much as it can. Use “anything except a quote” in brackets instead.
- **If** You pasted a lookahead from a forum **→ then** RE2 tools reject it. Use “Doesn’t match regex” or a second filter instead.
- **If** Search Console shows zero rows **→ then** Check the pattern before you panic about traffic. Paste a real query into a tester and see if it matches.

The exact fixes for the two trickiest ones:

```
Greedy:   "(.*)"     on  "a" and "b"   grabs   a" and "b
Fixed:    "([^"]*)"  on  "a" and "b"   grabs   a

Broken:   ^how|why       matches "the why of cake"  (oops)
Fixed:    ^(how|why)     doesn't
```

## Let the robot write it. Then check its homework

You can ask ChatGPT or Claude: “Write an RE2 regex for Google Search Console that matches queries starting with how, what or why.” They’re good at it. Say **RE2** and say **which tool**, so you don’t get a lookahead back.

Then **test it before you trust it**. Paste 5 strings that should match and 5 that shouldn’t into a tester like [regex101](https://regex101.com) (pick the Golang flavour, which uses RE2-style syntax), or straight into the Search Console filter. AI writes confident regex. Confident isn’t the same as correct.

> **The DumbCMO:** AI wrote you a regex in two seconds. Lovely. Spend two minutes testing it, or spend two months reporting the wrong numbers.

## The starter pack (copy all of this)

Swap “anita…bakes” for your brand, the cities for yours, and example\.com for your domain.

```
# SEARCH CONSOLE (partial match, ignores case)
Brand:          an(i|ee)th?a'?s?\s?bakes?
Questions:      ^(who|what|when|where|why|how|which|can|does|do|is|are|should|will)\b
Long-tail:      ^(\S+\s+){4,}\S+$
Commercial:     \b(best|top|vs|versus|reviews?|price|pricing|cost|cheap|alternatives?|compare)\b
Local:          near me|nearby|\b(pune|mumbai|bengaluru|bangalore|indiranagar)\b
Blog pages:     /blog/
Sections:       /(blog|guides|case-studies)/
Has params:     \?
Has UTMs:       [?&]utm_
Home page:      ^https://example\.com/$

# GA4 (full match, case-sensitive)
Blog pages:     .*/blog/.*
AI referrals:   .*(chatgpt|perplexity|gemini|copilot|claude).*

# GOOGLE SHEETS
Strip params:   =REGEXREPLACE(A2, "\?.*$", "")
Domain:         =REGEXEXTRACT(A2, "^(?:https?://)?(?:www\.)?([^/:?#]+)")
utm_source:     =REGEXEXTRACT(A2, "[?&]utm_source=([^&#]+)")
Ad time-wasters: =REGEXMATCH(LOWER(A2), "\b(free|jobs?|salary|course|classes|recipe|diy|template|internship)\b")
```

## Do this today

- [ ] Open Search Console → Performance. Add a Query → Custom (regex) filter with your brand pattern. Write down the clicks.
- [ ] Flip it to “Doesn’t match regex”. Write down non-brand clicks. That’s your real SEO number.
- [ ] Run the questions pattern with the brand excluded. Copy the top 20 questions into a doc. That’s next month’s content list.
- [ ] Filter pages with /blog/ and then your product folder. Compare CTR.
- [ ] If you run Google Ads, export search terms to Sheets and run the time-wasters formula. Add the obvious negatives today.
- [ ] Save your patterns somewhere (a note, a Sheet). Search Console doesn’t remember them for you.

## Not-so-frequently asked questions

### Do I need to learn programming for this?

No. The dozen symbols in the cheatsheet cover almost everything a marketer does. Copy, tweak, test.

### Is Search Console regex case-sensitive?

No. Google’s help page says matching ignores case by default. Add (?-i) at the start if you want case to count.

### Why does my pattern work in Search Console but not in GA4?

Search Console matches part of the value. GA4 wants the whole value to match. Add .* to both ends in GA4.

### Can I use lookaheads?

Not in Search Console, GA4, Looker Studio or Sheets. They use RE2, which doesn’t support them. Use the “doesn’t match” option instead.

### Is there a length limit in Search Console?

Google’s Daniel Waisberg has said 4,096 characters, as reported by Search Engine Land. I couldn’t find it on the help page, so treat it as roughly that.

### Can I use regex in Google Ads negative keywords?

No. Negative keywords are normal words and phrases. Use regex in Sheets (or scripts) to find which search terms to add as negatives.

### Can ChatGPT write these for me?

Yes, and it’s often good at it. Tell it RE2 and the tool name, then test with real examples before you report a single number.

## Things your agency won’t say

- A report that never splits brand from non-brand can make SEO look great while it’s just your reputation doing the work.
- “Advanced regex segmentation” in a proposal is often the patterns on this page. Ask to see the actual pattern.
- Twelve symbols, one tester, and the habit of checking 5 yes / 5 no examples. That’s the whole skill.

## Jargon Jail

**Locked up: “RE2”**

Google’s own regex engine. Search Console, GA4, Looker Studio, Sheets and Google Ads queries use it. **It’s fast and safe because it leaves out a few fancy tricks, mainly lookaheads and lookbehinds.** If a pattern from a forum won’t work in a Google tool, that’s usually why.

## The calm takeaway

Regex looks scary because it’s dense, not because it’s deep. Learn the dozen symbols, copy the starter pack, and remember two rules: Search Console matches part of the value and ignores case. GA4 and Looker Studio match the whole value and care about case.

Test every pattern against real examples. Then go find out how much of your traffic is people who already knew your name.

## Where to go next

- What the clicks mean now that AI answers sit on top: [DataForSEO Search Insider 2026](/blog/dataforseo-search-insider-2026)
- Why your Search Console report dates differ: [This week in Google](/blog/search-console-dates-answer-first-pages-ai-mode-ads)
- Free AI citation data from Bing: [Bing’s Topics Portfolio](/blog/bing-topics-portfolio-ai-performance)
- What a customer is worth before you cut ad waste: [CAC and LTV explained](/blog/cac-and-ltv-explained)
- Paid search basics: [Google Ads for beginners](/blog/google-ads-for-beginners)

## Sources

1. Google Search Console Help, [“Performance report (Search results): Advanced filtering and comparison”](https://support.google.com/webmasters/answer/17011165): RE2 syntax, partial match by default, not case-sensitive by default, `(?-i)`, Matches / Doesn’t match regex, Queries and Pages.
2. Google Search Central Blog, [“Search Console regex filters update and quick tips”](https://developers.google.com/search/blog/2021/06/regex-negative-match), June 2021: the negative “doesn’t match” option, and a pointer to RE2 syntax.
3. Search Engine Land, [“How to get the most out of the Google Search Console API using regex”](https://searchengineland.com/google-search-console-api-regex-389034): 4,096-character limit attributed to Daniel Waisberg.
4. Google Analytics Help, [“About regular expressions (regex)”](https://support.google.com/analytics/answer/1034324): full regex by default, case-sensitive, where GA4 supports regex.
5. Google Analytics Community, [“use regex in Comparisons”](https://support.google.com/analytics/thread/396670132/use-regex-in-comparisons): comparisons offer exact and partial matching (a community answer, not official docs).
6. Looker Studio Help, [“Regular expressions in Looker Studio”](https://support.google.com/looker-studio/answer/10496674), and Google Cloud, [REGEXP_MATCH](https://cloud.google.com/looker/docs/studio/regexpmatch) and [REGEXP_CONTAINS](https://cloud.google.com/looker/docs/studio/regexpcontains): RE2, whole-value match, case-sensitive with `(?i)`, raw strings.
7. Google Docs Editors Help, [REGEXMATCH](https://support.google.com/docs/answer/3098292): Sheets uses RE2 except Unicode character classes.
8. Google Ads API, [GAQL grammar](https://developers.google.com/google-ads/api/docs/query/grammar) and [case sensitivity](https://developers.google.com/google-ads/api/docs/query/case-sensitivity): `REGEXP_MATCH`, RE2.
9. Screaming Frog, [Custom extraction guide](https://www.screamingfrog.co.uk/guides/custom-extraction/) and [Web scraping tutorial](https://www.screamingfrog.co.uk/seo-spider/tutorials/web-scraping/): regex extraction, the dot matching new lines, up to 100 extractors.
10. RE2 project, [syntax reference](https://github.com/google/re2/wiki/Syntax).

## Related notes

- [Why GA4 and Search Console never match](https://dumbcmo.com/blog/ga4-vs-search-console-numbers): Search Console counts clicks on Google. GA4 counts visits once your page loads and its tracking runs. Privacy settings, cookie banners, redirects, time zones and bots all widen the gap. Small gaps are normal. Compare trends, not totals, and investigate only big or sudden gaps.
- [CAC and LTV, explained: what a customer costs and what they’re worth](https://dumbcmo.com/blog/cac-and-ltv-explained): CAC is what you spend on marketing to win one new customer. LTV is what that customer pays you over time. If a customer is worth much more than they cost, grow. If not, fix prices, repeat visits or costs before you spend more.

---

From [DumbCMO](https://dumbcmo.com): The marketing notes you were too embarrassed to take.
