# Google Ads MCP Server: Write Tools Are On by Default

> Google's Google Ads MCP server shipped four write tools on November 2, enabled by default. Its checksum guarantees integrity, not that a human approved.

[← Back to Blog](/blog/)

Developers November 9, 2026 9 min read

# Google Ads MCP Server: Write Tools Are On by Default

On November 2, Google’s official bridge between AI assistants and Google Ads gained the ability to change an account. The release shipped with a two-step checksum that reads like an approval gate. Read the code and it is something else — a very good guarantee about a different question.

On November 2, Google released version 0.0.6 of its open-source **Google Ads MCP server** — the official bridge between AI assistants and Google Ads accounts. The changelog is two lines. It is also the first release in the project’s history that can write to an account.

There was no announcement: the 25 most recent posts on the Google Ads Developer Blog, a window reaching back to July 23, mention MCP exactly zero times. And the four new write tools are switched on in the config file that ships inside the package.

If you installed this server on the strength of the word “read-only” — how it launched in October 2025, and how PPC Land reports Google’s integration guide still described it on October 30 — you are running something else now. But the write toggle is not the interesting part. The safety mechanism shipped alongside it is: a well-built control that guarantees something other than what its name suggests.

## What Shipped on November 2

The server went from three tools to seven. Its own MCP annotations are the clearest summary, because they record which tools the maintainers consider dangerous:

| Tool | What it does | Read-only | Flagged destructive |
| --- | --- | --- | --- |
| `search`, `get_resource_metadata`, `list_accessible_customers` | Query, describe, list accounts | Yes | — |
| `create_asset` | Creates text, image, sitelink, callout, snippet and video assets | No | No |
| `upload_video_asset` | Uploads a local video file to YouTube | No | No |
| `manage_labels` | Creates, updates, removes account labels | No | **Yes** |
| `manage_label_associations` | Attaches/detaches labels on campaigns, ad groups, keywords | No | **Yes** |

What it still cannot touch: campaigns, budgets, bids, keywords, campaign status. No tool in that list attaches an asset to a campaign or asset group either — `create_asset` leaves an asset in your library, unreferenced, serving to nobody until something else links it.

One detail in `upload_video_asset` deserves naming, because it is the only write tool producing an artifact outside your account: if you do not pass a channel ID, the video lands on a Google-managed YouTube channel linked to the ads account. Privacy defaults to `UNLISTED`.

## The Checksum Is an Integrity Control, Not an Approval Gate

Every write runs twice. The first call defaults to `validate_only=true`: the server validates the operation, sends it to the Ads API as a dry run where supported, and returns human-readable `change_items` plus a `checksum`. Only a second call with `validate_only=false`, identical parameters and that checksum will commit. Read `propose_and_confirm.py` and three things become clear.

**The checksum has no key.** `compute_checksum()` is a plain `hashlib.sha256()` over the customer ID and each operation’s deterministic serialization. The module imports `hmac`, but only for `compare_digest` — a constant-time comparison, not a keyed digest. It is a content hash, not a capability token.

**The server stores nothing between the two calls.** On the confirming call it does not look up the proposal you made. It recomputes the expected value from the parameters in the request it is handling right now — the same line runs on both paths, at the top of the function — and compares.

```
expected_checksum = compute_checksum(customer_id, operation_payload)

if validate_only:
    ...                      # dry run, then return the checksum
checksum_err = verify_checksum(..., expected_checksum=expected_checksum)
```

The consequence is structural: nothing in the confirm path can distinguish a checksum returned by a real dry run from one a client computed locally from the same parameters. The code is Apache-2.0 and the inputs belong to the caller. The dry run is not a precondition for the commit.

**The request to pause for a human is a sentence.** It lives in the `message` field of the proposal JSON: present the change items to the user and wait for explicit confirmation. That is an instruction to a language model, inside a payload the model is free to summarise, skip, or satisfy by asking itself. Thomas Wismer, a consultant who tested the release, put it plainly in remarks reported by PPC Land — the server cannot check whether a human approved in between, and if you want a hard stop you add your own. Reading the code independently, that is exactly right.

Be precise about what the mechanism does deliver, because it is not nothing: it guarantees that _what commits is what was validated_. The video tool goes further, binding the file’s size and modification time into the payload to prevent time-of-check-to-time-of-use swaps. Picture the failure this kills: a model proposes a callout reading “Free shipping over $50”, you approve it, and on commit it regenerates the text slightly differently. Silent drift between the thing reviewed and the thing written is a classic LLM failure, and the checksum makes it impossible. That is a control worth having. It is just not an approval.

## What a Server-Enforced Approval Looks Like, One Layer Down

Google already ships the other pattern, one layer down. The Ads API requires [multi-party approvals](https://ads-developers.googleblog.com/2026/11/upcoming-changes-to-multi-party.md) for sensitive actions, and on November 4 Google announced changes landing the week of December 7: access invitations are no longer created until the approval is granted, and a new `STALE_MULTI_PARTY_AUTH_REQUEST` error fires when the target resource changed after the review was created.

Pending state that outlives the request. A second party. Staleness detection. That is what it looks like when Google decides an action needs a human. Assets and labels did not get it, presumably because they are not classed as sensitive actions — a defensible call. The error is reading the checksum as its lightweight equivalent.

## The Default Is the Part That Will Bite

Which tools the server exposes is governed by `tools_config.yaml`. The file bundled with 0.0.6 enables all five namespaces, including the two new ones:

```
namespaces:
  customers: true
  search: true
  metadata: true
  labels: true     # new in 0.0.6
  assets: true     # new in 0.0.6
```

The README is explicit that read-only is now opt-in: set `labels: false` and `assets: false`. Resolution order is the `GOOGLE_ADS_MCP_TOOLS_CONFIG` environment variable, then a file in the working directory, then the bundled default. No file of your own means write tools.

The install route compounds it. The README’s pinned form is `pipx run --spec "google-ads-mcp==X.Y.Z"`. Unpinned, it resolves to the latest PyPI release, which has been 0.0.6 since November 2. A client config written in October that does not pin a version is running write tools today, with no action by anyone on your team.

## The Case for Not Caring

The strongest version of the opposite argument, which is mostly correct.

Start with the threat model. Your agent already holds the OAuth credential. The checksum was never a defence against the model — if a model has write tools and wants to write, it writes. Grading a parameter-integrity hash as an authorization control grades it against a job it never claimed, and the job it does claim is the one that actually goes wrong in practice. Stateless is the right call too: the `stdio` server is a short-lived subprocess, and any signing key would sit on disk beside the OAuth token anyway.

Then the blast radius. No budget, bid, keyword or campaign status. An unattached asset serves to nobody and no tool here can attach it, so the realistic worst case from a confused agent is a cluttered asset library — an afternoon of tidying, not a spend incident. And this is 0.0.6 of a sample with no blog post; treating a preview’s version bump as a governance event is overreading a changelog.

## Where That Argument Breaks

Most of it survives. Two parts do not.

### 1\. Labels are not decoration

The repository’s own annotations draw the line: both label tools are flagged destructive, both asset tools are not. The maintainers told you which half is dangerous, and the “clutter, not spend” defence only covers the half they cleared.

`manage_label_associations` creates and removes associations on campaigns, customers, ad groups and ad group criteria. In a mature account, labels are the join key: automated rules, scripts, bulk edits and saved reporting views all filter on them. Detach a label from a campaign and you have not changed a budget — you may have changed which campaigns a budget rule matches. The server cannot change your spend; it can change what your spend automation believes it is looking at.

### 2\. Approvals are granted against descriptions

Tool review is a paperwork exercise: someone reads what a thing does, writes it down, and signs off. A team that approved “read-only, for reporting and diagnostics” in October now holds a record that does not match the artifact. Nothing was violated — an open-source project shipped a feature — but the gap between the approval and the install is real, and the only thing that would have closed it is a version pin the quickstart does not use.

The “it is only 0.0.6” defence argues the same way once you follow it. A 1.0 with a migration guide would have been announced and pinned. A 0.0.x that publishes to PyPI and gets installed unpinned by its own quickstart is exactly the shape that propagates without anyone deciding to adopt it.

## What To Do This Week

1.  **Find out which version you are running.** Check `pipx list` and your MCP client config. If nothing pins a version, assume 0.0.6 and assume write tools.
2.  **Decide on label writes specifically, not writes in general.** Assets are close to harmless; label associations touch the keys your rules and scripts filter on. If you run automation off labels, set `labels: false`.
3.  **Pin both the version and the tool surface.** Install with `--spec "google-ads-mcp==0.0.6"` and point `GOOGLE_ADS_MCP_TOOLS_CONFIG` at your own `tools_config.yaml`, so the next write tool arrives as a decision instead of an upgrade.
4.  **Put the hard stop in the client.** The server will not wait for a human, so an approval belongs in your [orchestration layer](/blog/multi-platform-ai-ad-orchestration.md) — where your spend caps and change windows already live.
5.  **Use the checksum for what it is good at.** Read the `change_items` on the proposal; the guarantee that the reviewed change is the committed change is strong and worth exercising.
6.  **Write down the date and the config you left in place, per account.** By January nobody will remember the server changed shape.

## The Takeaway

Google shipped a competent integrity control and no approval gate, enabled the tools behind it by default, and did not announce the release. Each is defensible alone; together they produce a tool most teams will describe to each other inaccurately.

The pattern across every official ad-platform MCP server — [Meta’s connectors](/blog/meta-ads-ai-connectors-mcp-2026.md), [TikTok’s server](/blog/tiktok-ads-mcp-server-2026.md), [the rest](/blog/mcp-ai-agents-advertising.md) — used to be simple: the platform ships the pipe, guardrails are your problem. This release is the more awkward successor. The platform shipped a guardrail, it is a good one, and it does not do the job its name implies. Reading what a shipped control actually guarantees is now the skill, because “propose and confirm” sounds like a human in the loop and resolves, in code, to a hash of your own parameters.

_Sources: [v0.0.6 release notes](https://github.com/googleads/google-ads-mcp/releases/tag/v0.0.6) (published 15:48 UTC, November 2, 2026), [propose\_and\_confirm.py](https://github.com/googleads/google-ads-mcp/blob/v0.0.6/ads_mcp/propose_and_confirm.py) and [tools\_config.yaml](https://github.com/googleads/google-ads-mcp/blob/v0.0.6/ads_mcp/tools_config.yaml) at that tag, [the PyPI release history](https://pypi.org/project/google-ads-mcp/), [Google Ads Developer Blog — multi-party approvals (November 4, 2026)](https://ads-developers.googleblog.com/2026/11/upcoming-changes-to-multi-party.md), and [PPC Land](https://ppc.land/google-ads-mcp-server-gains-4-write-tools-still-cant-change-budgets/), which reported the release and Wismer’s testing. Annotations come from the repository’s golden tool list; the missing announcement was checked against the 25 most recent developer-blog entries._

### Give your agents a surface you control.

Ads Agents connects AI agents to Google, Meta, Amazon and TikTok over [MCP](/mcp.md) — with spend caps, action allowlists and approval gates enforced in the orchestration layer, not requested in a tool description.

[Get Started Free →](https://app.ads-agents.com/registration)
