Google Ads match types in practice: exact isn’t exact, phrase isn’t safe

A real tuning log: six match-type changes in ten days

Between June 2 and June 11, one B2B search account, the same one behind the hidden search terms incident, shipped six keyword match-type changes: tightenings, removals, one near-disaster, and a final wholesale conversion to exact. Each change was a reaction to something the previous match type did to spend. That log is the curriculum.

Match types match meanings, not words

Google's keyword matching documentation defines all three types in terms of meaning. Exact match [keyword] shows ads on searches with "the same meaning or same intent as the keyword." Phrase match "keyword" covers searches that "include the meaning of your keyword", and "the meaning can be implied." Broad match reaches searches "related to your keyword," including ones that "don't contain the direct meaning" at all. None of those definitions promises to match the words you typed. Matching is a model's judgment about meaning; the types differ only in how far that judgment may roam.

Exact match isn’t exact

The account ran [data access control] as an exact keyword. Close variants stretched it onto generic "X access control" queries, wasting about $25 in one day on searches with the right words and the wrong product. The fix wasn't a match-type change; it was campaign negatives (cyber, cybersecurity, information security). Exact narrows the meaning radius, but you still need negatives to fence it.

Phrase match sprays — invisibly

The same campaign's phrase keywords ("privileged access management", "sql access control") close-variant matched into PAM vendor brands, platform RBAC how-tos, and observability tooling queries. Adjacent in words, wrong in intent. Worse, most of the spray was unreviewable: on the worst day, 83% of the campaign's spend sat in the "Other search terms" row, queries you can't see. Spray you can't audit is the real cost of phrase match.

Words match; intent doesn’t

One removal had nothing to do with match-type mechanics: "database migration tool" as a phrase keyword. The words look perfect for a schema-change product, but people searching it want to move data between databases, a different product entirely. No match type fixes a keyword whose searchers want something you don't sell.

The keyword the cleanup almost killed

The counterweight to all this tightening: the phrase keyword "privileged access management" was dropped in the spray cleanup — and it had driven every contact-form lead in May and June. It was revived the same day, when the conversion column finally got read. Tightening sweeps read the cost column; revenue often lives in exactly the loose keyword you're about to delete. Judge keywords by conversions before match type.

A ladder that survives contact with spend

1. Branded and competitor keywords: exact from day one. There's no discovery to be had on a brand name.
2. Run phrase (or broad with smart bidding) as deliberate discovery instruments: a few, watched weekly, with negatives ready.
3. Harvest winners into exact. A converting search term becomes an exact keyword; the discovery keyword keeps hunting.
4. Tighten when spray outruns discovery. Rising spend with flat conversions, or a growing "Other search terms" share, means a phrase keyword has stopped finding and started leaking.
5. Know the conversion mechanics. Match type is immutable: converting phrase to exact archives the old keyword and creates a new one with a fresh ID and reset history. The final cleanup here was 14 archives plus 14 creates.

How the changes actually shipped

Every change above is a git commit, because the account runs on Adjar: keywords and match types live in config, and a match-type conversion is a diff:

 [[campaigns.ad_groups.keywords]]
 text = "database access management"
-match = "PHRASE"
+match = "EXACT"

The rhythm each time: pull the search terms, reason about intent in the commit message, apply. And the revival that saved the best keyword was possible because the removal was a commit, not a console deletion — git remembered what the console buried.