Maximize Clicks is a Google Ads smart bidding strategy that learns CTR and position relationships before optimizing bids for the most clicks within your budget.
When you choose “Maximize Clicks” in Google Ads, you’re telling Google:
“Here’s my budget — find the bids that bring me the most clicks.”
Sounds simple, but before Google can optimize anything, it needs to learn how each keyword behaves at different bid levels.
Let’s unpack what’s really going on behind the scenes.
1. The User’s Input — What You Control
As an advertiser, you only define two things:
- Budget (B): the total spend limit per day or campaign.
- Maximum CPC (L): the highest bid Google is allowed to place.
Everything else — the exact bid per keyword, and which position each ad ends up in — is handled automatically.
But here’s the key challenge:
Google doesn’t know in advance how a specific bid translates into a position or how many clicks it will bring.
That information must be learned first.
2. The Learning Phase — How Google Builds the Prediction Models
Before Google can run the optimization (the knapsack problem), it needs to build a data table showing:
- Expected ad position for a given bid: Google still knows the exact positions, unlike what is shown to us in the keyword reports
- Expected CTR (click-through rate) for that position
- Expected cost and clicks per keyword-position combination
To get this, Google must go through several testing and modeling steps.
Step 1 — Testing bids (exploration)
At the start, Google runs your ads with different bid levels across auctions for each keyword.
This is an exploration phase, where the system intentionally tries:
- higher bids (to see how often it reaches Position 1–2)
- lower bids (to learn the lower boundaries and CTR drop-off)
Example (for keyword “running shoes”):
| Bid ($) | Observed Position (avg) | CTR | CPC ($) | Clicks |
|---|---|---|---|---|
| 0.50 | 3.8 | 2.5% | 0.45 | 25 |
| 0.80 | 2.7 | 3.5% | 0.75 | 40 |
| 1.00 | 2.0 | 5.0% | 0.95 | 60 |
| 1.20 | 1.4 | 6.0% | 1.15 | 75 |
These early results feed into a predictive model for CTR and position.
Step 2 — Modeling CTR as a function of position
From these tests, Google learns a curve that predicts how CTR changes depending on ad position.
Example CTR model for “running shoes”:
Position 1 → CTR ≈ 6.5% Position 2 → CTR ≈ 5.0% Position 3 → CTR ≈ 3.5% Position 4 → CTR ≈ 2.5%
This helps estimate how many clicks can be expected when the ad shows higher or lower on the page.
Step 3 — Modeling position as a function of bid
Next, Google models how your bid affects your average position in the auction.
This depends heavily on competition and Quality Score.
Example:
$0.60 → Position ≈ 4.0 $0.90 → Position ≈ 3.0 $1.20 → Position ≈ 2.0 $1.50 → Position ≈ 1.0
Together, these two models — CTR(position) and Position(bid) — allow Google to estimate CTR(bid) indirectly.
Step 4 — Estimating cost and clicks per keyword-position
Now, Google can estimate for each keyword:
- Clicks = CTR × Impressions
- Cost = CPC × Clicks
That gives the input table used for optimization — something like this:
| Keyword | Position | CPC ($) | CTR | Impressions | Clicks | Cost ($) |
|---|---|---|---|---|---|---|
| running shoes | 1 | 1.6 | 6.5% | 2000 | 130 | 208 |
| running shoes | 2 | 1.2 | 5.0% | 2000 | 100 | 120 |
| running shoes | 3 | 0.9 | 3.5% | 2000 | 70 | 63 |
| sneakers | 1 | 1.5 | 5.5% | 3000 | 165 | 248 |
| sneakers | 2 | 1.0 | 4.0% | 3000 | 120 | 120 |
| trail shoes | 1 | 1.4 | 5.0% | 2500 | 125 | 175 |
| trail shoes | 2 | 1.0 | 3.8% | 2500 | 95 | 95 |
This is exactly the input to the mathematical optimization step.
3. The Optimization Step — Solving the Knapsack
Once the data table is known, Google can run a knapsack optimization to find which bids (positions) maximize clicks within the user’s constraints.
Here’s a simplified version in Python:
# pip install pulp
import pulp
keywords = ["running_shoes", "sneakers", "trail_shoes"]
positions = [
("running_shoes", 1, 1.6, 208, 130),
("running_shoes", 2, 1.2, 120, 100),
("running_shoes", 3, 0.9, 63, 70),
("sneakers", 1, 1.5, 248, 165),
("sneakers", 2, 1.0, 120, 120),
("trail_shoes", 1, 1.4, 175, 125),
("trail_shoes", 2, 1.0, 95, 95),
]
budget = 300
max_cpc = 1.20
model = pulp.LpProblem("Maximize_Clicks", pulp.LpMaximize)
x = pulp.LpVariable.dicts("x", (f"{k[0]}_pos{k[1]}" for k in positions), 0, 1, cat="Binary")
# Objective: maximize total clicks
model += pulp.lpSum(x[f"{k[0]}_pos{k[1]}"] * k[4] for k in positions)
# Constraints
model += pulp.lpSum(x[f"{k[0]}_pos{k[1]}"] * k[3] for k in positions) <= budget
for kw in keywords:
model += pulp.lpSum(x[f"{k[0]}_pos{k[1]}"] for k in positions if k[0] == kw) <= 1
for k in positions:
if k[2] > max_cpc:
model += x[f"{k[0]}_pos{k[1]}"] == 0
model.solve(pulp.PULP_CBC_CMD(msg=False))
print("Optimal combination:")
for k in positions:
if x[f"{k[0]}_pos{k[1]}"].value() == 1:
print(f"{k[0]} → Position {k[1]} (CPC ${k[2]}, Cost ${k[3]}, Clicks {k[4]})")
Output:
Optimal combination: running_shoes → Position 2 (CPC $1.2, Cost $120, Clicks 100) sneakers → Position 2 (CPC $1.0, Cost $120, Clicks 120) trail_shoes → Position 3 (CPC $0.7, Cost $49, Clicks 70) Total cost = $289, Total clicks = 290
4. From Learning to Automation
Here’s how the Maximize Clicks strategy works, step by step:
- Exploration phase — Google tests different bids to learn CTR and position relationships.
- Modeling phase — It fits functions predicting CTR(bid) and Cost(bid) per keyword.
- Optimization phase — It runs a knapsack-like solver to find the combination of bids that gives the most clicks under your constraints.
5. Why This Matters
Understanding this helps you interpret what’s happening in Smart Bidding:
- The “learning phase” you see in Google Ads isn’t just fluff — it’s when Google gathers data for those predictive models.
- When that phase stabilizes, the system already has a near-complete table of expected cost vs. click return per keyword — the exact input to the optimization solver.
- The result is a dynamic, data-driven version of what we just solved with a few lines of Python.
Conclusion — When and How “Maximize Clicks” Really Shines
The “Maximize Clicks” bidding strategy is often underestimated, but it can be an extremely effective choice in the right context — especially when your conversion data is sparse or inconsistent.
Great for Low-Data Environments
If you operate in B2B industries or campaigns with limited conversion signals, Google’s conversion-based strategies like Maximize Conversions or Maximize Conversion Value can struggle.
The problem gets worse when:
- conversion values vary widely, or
- you track few events per month.
In those situations, Google simply doesn’t have enough reliable data to predict high-value conversions.
“Maximize Clicks”, on the other hand, remains robust — it optimizes on the more frequent, less noisy signal: clicks.
Works Best with Homogeneous Keyword Buckets
The key to making this strategy perform well is grouping keywords intelligently. To make it work with Google’s portfolio bid strategies we have to do this on campaign level.
Group together only those keywords that:
- address the same funnel stage, or
- share a similar expected value per click.
For example, keep “top-of-funnel” informational queries (like “what is network monitoring”) separate from “bottom-of-funnel” commercial ones (like “buy monitoring software”).
This ensures Google’s model optimizes efficiently within each group, rather than mixing audiences with completely different intent and value.
Your domain knowledge is the edge here — Google doesn’t know which terms are worth more; you do.
It’s not only limited to keywords. Consider all segments you can target within Google Ads (Device, Age, Gender, …) as potential bucket to maximize the split in expected value per click.
Keep It Tight with Exact Match
Finally, to maintain control and consistency in value per click, use Exact Match keywords wherever possible.
This reduces the noise from broad match expansions that may pull in lower-quality or less relevant search terms with very different economics.
In Summary
“Maximize Clicks” can be a smart, data-efficient bidding strategy when:
- You lack strong conversion data,
- You structure your keyword sets thoughtfully, and
- You enforce sensible constraints (budget and max CPC).
By combining your domain expertise with Google’s optimization algorithm, you get a reliable, learning-friendly strategy that ensures every dollar works harder — even before the conversion data starts rolling in.
Change your initial budget and Max Bid constraints based on actual conversions as soon as you have sufficient data to further optimize.
