Skip to main content
This guide connects your Google Ads account to Adjar, exports it as plain-text config, and walks your first change through the full loop — ask, review, apply, measure. The whole process takes about 10 minutes.

​
Prerequisites

Before you begin, make sure you have:
  • The adjar CLI installed
  • A Google Ads account you want to manage, with API access
  • An AI agent or assistant (Claude Code, Cursor, or any other)

​
Install the CLI

macOS (Apple silicon + Intel): 
curl -fsSL https://adjar.ai/install.sh | bash
This downloads the standalone adjar binary, verifies its checksum, and installs it to ~/.local/bin — no Node or other runtime required.
macOS only for now. Linux and Windows builds are on the way.
Verify the installation: 
adjar --version

​
Set up credentials

Follow Get Google Ads API access to produce your google.json file, then point Adjar at it: 
export ADJAR_CREDENTIALS=/path/to/google.json
Or pass --credentials /path/to/google.json on any command. Your account ID is the customer_id in that file — you’ll pass it to adjar import next.

​
The loop: ask, review, apply, measure

Adjar replaces the Google Ads console with a config-driven workflow. Your account lives as plain-text TOML in your repo, your AI agent edits it, and the adjar CLI turns the diff into a reviewable plan it applies only when you approve. The performance report Adjar pulls back becomes your next ask. Import your account once, then run the loop.
1

Import your account

Export your entire Google Ads account into local TOML config. Replace <id> with your customer_id.
adjar import --account <id> -o config/google.toml
Adjar writes every campaign, ad group, keyword, and creative into config/google.toml as plain text you can version-control. Re-run it anytime to refresh the file from the live account.
Large accounts can be split across multiple files with a top-level imports directive. See the config reference.
2

Commit your config

Add the config to version control. This is the baseline — every future change shows up as a diff against it.
git add config/
git commit -m "chore: initial adjar config export"
Store your config in the same repo as your website or app, so your AI agent already has the context it needs when you ask it to work on ads.
3

Ask your agent to make a change

Open your AI agent and tell it what you want in plain language. It reads your config, then edits the TOML directly — no special prompt engineering, the format is self-describing.
"Pause the keywords in the running-shoes campaign with a
 cost-per-conversion above $50 and fewer than 2 conversions
 this month."

● Read config/google.toml
● Edited config/google.toml
   2 keywords status ENABLED → "PAUSED"
4

Review the plan

Before anything touches your live account, run adjar plan. Adjar compares your local config against the live account and prints every change as a diff:
adjar plan --config config/google.toml
The plan shows:
  • Fields being changed, with old vs. new values
  • New campaigns, ad groups, or keywords being created
  • Resources being paused or removed
  • Warnings — e.g. a change that would reset a campaign’s learning period
Nothing is applied until you approve.
5

Apply the changes

If the plan looks right, apply it:
adjar apply --config config/google.toml
Adjar executes the changes against the Google Ads API and writes the assigned IDs back into your config. Commit the result — your repo is now the source of truth:
git add config/
git commit -m "feat: pause high-CPA keywords in running-shoes campaign"
Every change is a git commit. If an experiment underperforms, rollback is git revert — not a hunt through the console’s change history.
6

Pull a performance report

Close the loop: adjar report pulls a month of performance as plain-text markdown, written right beside your config. Pass --month for a calendar month, or omit it to default to the last complete month.
adjar report --config config/google.toml --month 2026-05 -o reports/2026-05.google.md
Need a single day instead? Pass --day 2026-05-31. It’s mutually exclusive with --month.
Config and report are both plain text, so next round your agent reads them side by side — spotting the keyword that spends without converting before it proposes the next change. A report looks like:
## Daily breakdown
### 2026-05-31
| Campaign      | Clicks |   CTR |    Cost | Conv. |
| ------------- | -----: | ----: | ------: | ----: |
| Running Shoes |    140 | 2.90% | $182.40 |     6 |
| Trail Shoes   |     86 | 1.74% | $121.10 |     2 |
Commit it alongside your config, and the next ask starts here.
That’s the full loop — and it repeats. Each round starts from the latest report.

​
How the pieces fit together

PieceWhat it does
TOML configDeclarative representation of your entire ad account
Markdown reportsPerformance data your agent can read
adjar importExports your live account into TOML the first time
adjar planCompares local config to the live account; prints the diff
adjar applyExecutes the diff against the Google Ads API
adjar reportPulls performance into a Markdown report
Your AI agentReads config + reports, proposes edits, explains its reasoning
YouReview every plan, approve what ships, provide judgment

​
Next steps

CLI Reference

The core workflow plus full flags and options for every command.

Config Reference

Understand every field in your TOML config.

File Organization

How to split config across files and how imports composes them.

adjar report

Pull performance into Markdown that closes the loop.