How to Manage 20 SEO Clients with Claude Code

Key Takeaways

• Agency SEO delivery takes 10-15 hours per client per month on average for manual audits, reporting, and analysis. At 20 clients, that's a 200-300 hour monthly burden before any strategy work happens (Databox State of SEO Reporting, 2025)
• Claude Code can run audits across all clients in parallel using a shared project structure and per-client config files. Sequential manual audits become concurrent automated runs
• Per-client CLAUDE.md files give Claude Code context about each client's business, priorities, and GSC/GA4 property IDs without repeating instructions every session
• Report generation time could drop significantly when you template the output format and feed Claude Code structured JSON data instead of raw exports — the bottleneck shifts from writing to reviewing
• The directory structure matters. Agencies that mix client data in a shared folder lose the isolation that makes parallel execution safe and auditable
• Start with the SEO Command Center setup before attempting multi-client workflows — the single-client setup is the foundation everything else builds on

Agency SEO delivery has a ceiling. Every account manager and delivery lead hits it somewhere between 10 and 15 clients. The math is straightforward: if audits, reporting, and analysis consume 12 hours per client per month, a team of two handles 16 clients before quality degrades. Adding a third team member doesn't fix the structure. It delays the next ceiling.

A 2025 Databox survey found that 61% of SEO agencies cite reporting as their highest time-cost activity, and 43% of delivery leads spend more than 30% of their working hours on tasks they describe as "repetitive but unavoidable." The tools haven't changed the ratio — they've just made the repetitive tasks faster to execute one at a time.

Claude Code changes the ratio by running tasks across clients simultaneously, generating templated outputs from structured data, and holding per-client context between sessions. This guide covers the exact setup: directory structure, per-client configs, parallel audit execution, and automated reporting.

The Agency Scale Problem

Manual SEO delivery breaks past 10 clients because every task is client-specific and sequential. Audit client A, export the results, format the report, repeat for client B. Each step requires human context-switching: different domains, different priorities, different stakeholders, different GSC properties. The time cost is not the audit itself. It's the overhead of switching context 10-20 times a month.

Most agencies respond to this by adding headcount or buying more tools. Neither fixes the root problem. Headcount adds more people running the same sequential process. Tools speed up individual tasks but don't eliminate the switching overhead or automate the synthesis step where data becomes a client-facing deliverable.

Context switching is the real tax. A Semrush report for client A takes 15 minutes to pull and format. The same report for client B takes another 15 minutes. Not because the task is hard but because you're doing it separately, manually, for each account. Claude Code with a multi-client project structure collapses that repetition: define the task once, run it across all clients.

Report synthesis is the second tax. Raw audit data from Screaming Frog, GSC exports, and rank tracking tools don't turn into client-facing reports without a human reading, interpreting, and writing the summary. That interpretation step consumes the most senior time in any delivery team. Claude Code can do the synthesis given structured input data and a clear output template.

The ceiling for a two-person delivery team running this workflow isn't 16 clients. A parallel Claude Code setup could let the same headcount handle significantly more accounts — shifting recovered time toward strategy instead of formatting.

Project Structure for Multi-Client Workflows

A well-structured multi-client Claude Code project keeps each client's data isolated, makes audits runnable without context switching, and lets Claude Code load the right configuration for each account automatically. The directory structure below is the foundation.

agency-seo/
├── CLAUDE.md                    # Global agency context and instructions
├── shared/
│   ├── skills/                  # Reusable Claude Code skills (.md files)
│   │   ├── site-audit.md
│   │   ├── gsc-analyzer.md
│   │   ├── report-generator.md
│   │   └── cannibalization-check.md
│   ├── templates/
│   │   ├── monthly-report.md    # Report output template
│   │   └── audit-summary.md    # Audit summary template
│   └── fetchers/
│       ├── fetch_gsc.py         # GSC data fetcher (shared)
│       ├── fetch_ga4.py         # GA4 data fetcher (shared)
│       └── run_all_clients.sh   # Parallel execution script
├── clients/
│   ├── client-acme/
│   │   ├── CLAUDE.md            # Client-specific context
│   │   ├── config.json          # GSC/GA4 property IDs, priorities
│   │   ├── data/
│   │   │   ├── gsc/             # GSC JSON exports
│   │   │   ├── ga4/             # GA4 JSON exports
│   │   │   └── audits/          # Screaming Frog exports, crawl data
│   │   └── reports/             # Generated client reports
│   ├── client-beta-co/
│   │   └── ... (same structure)
│   └── client-gamma-inc/
│       └── ... (same structure)
└── tasks/
    └── todo.md                  # What's in progress across accounts

The Global CLAUDE.md

The root CLAUDE.md gives Claude Code agency-wide context: your methodology, output standards, and what format every client report follows.

# Agency SEO Delivery Context

## Who We Are
10-person SEO agency. Deliver monthly technical audits, GSC analysis,
and content recommendations for 22 active clients.

## Delivery Standards
- Monthly reports go to clients as Markdown (we convert to PDF)
- All recommendations must include estimated effort: Low / Medium / High
- Priority ranking: technical issues > content gaps > keyword opportunities
- Never recommend a fix without explaining the business impact

## Report Format
Follow shared/templates/monthly-report.md exactly.
Output should be client-ready without editing.

## Data Location
Each client's data lives in clients/{client-slug}/data/
Never mix data between client directories.

## Skills Available
Shared skills are in shared/skills/. Run them with:
> Run site-audit for this client using data in ./data/audits/

The Per-Client CLAUDE.md

Each client directory gets its own CLAUDE.md. When Claude Code opens from clients/client-acme/, it loads both the root and local config. The local file overrides or extends the global context.

# Client: Acme Corp

## Business Context
B2B SaaS. HR software. ICP: HR directors at companies 50-500 employees.
Primary conversion: demo request. Secondary: whitepaper downloads.

## SEO Priorities (in order)
1. Fix crawl budget issues — Googlebot wasting 40% on faceted nav URLs
2. Improve position 5-15 rankings for "HR software" cluster
3. Build content for "employee onboarding" topic cluster (zero coverage)

## Properties
- Domain: acme-corp.com
- GSC property: https://www.acme-corp.com/
- GA4 property ID: 287493012
- Primary competitor: competitor-a.com

## Client Sensitivities
- No recommendations that require dev work over 5 hours (small eng team)
- CMO reviews all reports — keep executive summary under 150 words
- They track "demo requests" as primary KPI, not traffic

This structure means Claude Code opens any client folder and immediately knows the business, the priorities, and the property IDs without you re-explaining anything.

Parallel Site Audits Across Clients

Running audits one at a time is the default because most tools are built for single-site analysis. Claude Code is not a tool with a UI. It's a runtime that executes code. That means you can script it to run across all client directories simultaneously, the same way you'd run any shell process in parallel.

The Parallel Execution Script

The shared run_all_clients.sh script iterates over every client directory and triggers the data fetch in the background. All clients run at the same time.

#!/bin/bash
# run_all_clients.sh
# Fetches GSC and GA4 data for all active clients in parallel

CLIENTS_DIR="./clients"
LOG_DIR="./logs/$(date +%Y-%m-%d)"
mkdir -p "$LOG_DIR"

for client_dir in "$CLIENTS_DIR"/*/; do
  client_name=$(basename "$client_dir")
  config="$client_dir/config.json"

  if [ ! -f "$config" ]; then
    echo "Skipping $client_name — no config.json found"
    continue
  fi

  echo "Starting fetch for $client_name..."
  (
    python3 shared/fetchers/fetch_gsc.py \
      --config "$config" \
      --output "$client_dir/data/gsc/" \
      >> "$LOG_DIR/$client_name-gsc.log" 2>&1

    python3 shared/fetchers/fetch_ga4.py \
      --config "$config" \
      --output "$client_dir/data/ga4/" \
      >> "$LOG_DIR/$client_name-ga4.log" 2>&1

    echo "$client_name: fetch complete"
  ) &
done

wait
echo "All client data fetches complete."

Run it once at the start of your monthly delivery cycle:

chmod +x shared/fetchers/run_all_clients.sh
./shared/fetchers/run_all_clients.sh

For 20 clients with 90-day GSC data pulls, this typically completes in 8-12 minutes. Without parallelization, the same pulls run sequentially in 2-3 hours.

Running Audits Per Client

Once data is fetched, open Claude Code in each client directory and run the audit skill:

cd clients/client-acme
claude

Then inside Claude Code:

Run site-audit using the crawl data in ./data/audits/ and GSC data
in ./data/gsc/. Cross-reference crawled URLs against indexed URLs.
Flag pages that are crawled but not indexed, and pages indexed
but not crawled in the last 30 days.

Claude Code reads both the global CLAUDE.md and the local client-acme/CLAUDE.md automatically. It knows this client's priorities without you restating them.

Batching the Audit Run

If you want to run audits across all clients without switching directories manually, use a wrapper:

#!/bin/bash
# audit_all_clients.sh

for client_dir in ./clients/*/; do
  client_name=$(basename "$client_dir")
  echo "=== Auditing $client_name ==="

  cd "$client_dir"
  claude --print "Run site-audit using data in ./data/audits/ and ./data/gsc/. Output findings to ./reports/audit-$(date +%Y-%m).md following the shared audit template."
  cd - > /dev/null

  echo "$client_name: audit complete"
done

The --print flag runs Claude Code non-interactively and exits after completing the task. This lets you queue all audits and walk away.

Automated Client Reporting

Automated client reporting with Claude Code works when you give it structured input (data files), a fixed output template, and client context (the CLAUDE.md). When all three are in place, the bottleneck shifts from writing the report to reviewing it — which is a substantially shorter task.

The Report Template

The shared report template defines the exact structure every client report follows. Claude Code reads this template and fills it with client-specific findings.

# [Client Name] — SEO Monthly Report
**Period:** [Month Year]
**Prepared by:** [Agency Name]

---

## Executive Summary
[150 words max. Primary KPI status. 3 most important findings.
Recommended action for next 30 days.]

---

## Technical SEO Status

### Critical Issues (Fix immediately)
| Issue | Pages Affected | Business Impact | Effort |
| --- | --- | --- | --- |
| [Issue] | [Count] | [Impact] | Low/Med/High |

### Moderate Issues (Fix this quarter)
[Same table format]

### Monitoring (Watch list)
[Bulleted list of issues to track but not action yet]

---

## Organic Performance (GSC Data)

### Impressions & Clicks
[Month-over-month comparison. Trend direction. Notable changes.]

### Position Movement
| Keyword Cluster | Avg Position | Change | Trend |
| --- | --- | --- | --- |

### Top Opportunities (Position 5-15)
[Keywords close to page 1 with volume worth pursuing]

---

## Recommended Actions for [Next Month]

| Priority | Action | Effort | Expected Impact |
| --- | --- | --- | --- |
| 1 | [Action] | [hrs] | [Impact] |

---

## Appendix
[Raw data tables if client requests them]

Generating the Report

With data fetched and the template defined, generating a report is one Claude Code prompt:

Read the GSC data in ./data/gsc/ and the audit findings in
./reports/audit-2026-03.md. Generate the monthly report for
March 2026 following the template in ../../shared/templates/monthly-report.md.

Client context: this is Acme Corp, a B2B SaaS company. Their primary
KPI is demo requests, not traffic volume. The CMO reads every report.
Keep the executive summary under 150 words and lead with business
outcomes, not metrics.

Save the output to ./reports/monthly-2026-03.md

Claude Code reads the template, loads the data, applies the client context from CLAUDE.md, and produces a draft. Plan for 10-15 minutes to spot-check numbers against source data and adjust phrasing for client relationships before sending.

Managing Client-Specific Configurations

Scaling to 20 clients creates configuration drift. Different clients have different GSC properties, different GA4 configurations, different priority keywords, and different reporting cadences. Without a systematic approach, this becomes a maintenance burden that erodes the time savings you built the system to capture.

The config.json per client is the single source of truth for all property IDs and account-specific settings. The CLAUDE.md holds the business and strategic context. Keep them separate.

The config.json Schema

{
  "client": {
    "name": "Acme Corp",
    "slug": "client-acme",
    "domain": "acme-corp.com",
    "industry": "B2B SaaS / HR Software",
    "reporting_cadence": "monthly",
    "primary_kpi": "demo_requests"
  },
  "google": {
    "gsc_property": "https://www.acme-corp.com/",
    "ga4_property_id": "287493012",
    "ads_customer_id": "8821049376",
    "service_account_key": "../../shared/keys/service-account.json"
  },
  "tracking": {
    "primary_keywords": [
      "hr software",
      "employee onboarding software",
      "hr management platform"
    ],
    "competitor_domains": [
      "competitor-a.com",
      "competitor-b.com"
    ],
    "target_positions": {
      "hr software": 3,
      "employee onboarding software": 5
    }
  },
  "delivery": {
    "report_recipients": ["cmo@acme-corp.com"],
    "slack_channel": "#seo-updates",
    "notes": "No recommendations requiring more than 5 hours dev effort"
  }
}

One service account key covers all clients. The key file lives in shared/keys/ and each config.json references it by relative path. Add the service account email to each client's GSC and GA4 property with read access.

Updating Configs at Scale

When you onboard a new client or a client changes their GA4 property, you update one JSON file. The next time the audit or report runs, it picks up the change automatically. No dashboard to update. No manual re-authentication.

To audit your configuration coverage across all clients:

for config in ./clients/*/config.json; do
  client=$(jq -r '.client.name' "$config")
  gsc=$(jq -r '.google.gsc_property' "$config")
  ga4=$(jq -r '.google.ga4_property_id' "$config")
  echo "$client | GSC: $gsc | GA4: $ga4"
done

Output:

Acme Corp    | GSC: https://www.acme-corp.com/    | GA4: 287493012
Beta Co      | GSC: https://www.beta-co.com/      | GA4: 319482011
Gamma Inc    | GSC: https://www.gamma-inc.com/    | GA4: 402817293

Spot missing or incorrect IDs before running a 20-client data pull.

When Client Priorities Change

Mid-year priority shifts happen. A client moves from "fix crawl budget" to "rank for new product category." Update the local CLAUDE.md for that client. The next time Claude Code runs in their directory, it operates with the new context. You don't retrain anything or reconfigure a tool. You edit a text file.

This is the structural advantage of configuration-as-text. Every client's context is version-controllable, readable, and editable without opening a dashboard.

For clients with significant context — competitive histories, past penalties, complex site architectures — keep a notes.md file in the client directory alongside the CLAUDE.md. Reference it explicitly when running audits:

Before running the audit, read ./notes.md for historical context
on this client's site. They had a manual action in 2024 that was
resolved. Flag any patterns that look related.

FAQ

How many SEO clients can one person manage with this workflow?

The answer depends on client complexity and reporting depth. The constraint shifts from time to cognitive load: you still need to review AI-generated output, make strategic calls, and handle client relationships. Claude Code removes the repetitive execution work. It does not remove the thinking. How far you can push that ratio depends on how much of the work in your current process is mechanical versus judgment-based.

Do I need a separate Claude Code subscription for each client?

No. One Claude Max subscription runs across all client directories. Claude Code is a terminal tool, not a per-seat SaaS platform. You switch between client directories manually or script the switching. Anthropic's API usage costs scale with the volume of tokens processed, but for typical agency audit and reporting work, the monthly API cost across 20 clients is $30-80 depending on report length and data volume.

How does Claude Code handle sensitive client data?

Claude Code processes data locally in your terminal environment. Nothing leaves your machine through Claude Code itself — API calls go to Anthropic's servers, but the data files stay local. For highly sensitive clients, keep their directories off cloud sync (add to .gitignore). For most agencies, the risk profile is equivalent to running any local analysis tool against downloaded CSV exports.

What's the minimum viable setup to start with multi-client workflows?

Start with two clients. Create the directory structure above, write a CLAUDE.md for each, and run a manual data fetch with the shared Python scripts. Generate one report using the template. The goal is to prove the template works before you run it across 20 accounts. Once you trust the output quality, automate the fetch with the shell script and batch the report generation. Don't automate before you trust the output.

Can Claude Code generate reports that go directly to clients?

Do not send Claude Code output directly to clients without human review. Spot-check numbers against source data files — hallucinations on data analysis tasks are rare but they happen. The value is that review replaces writing as the primary time cost. The human stays in the loop; the loop is shorter. For a deeper look at the single-client setup that underpins this workflow, see the SEO Command Center guide.

How do I handle clients who want real-time reporting or dashboards?

Claude Code is not a dashboard replacement. It's an analysis and generation tool for periodic deliverables. For clients who want live data, pair this workflow with Looker Studio for the client-facing view and use Claude Code for the monthly synthesis and strategic narrative on top of the dashboard. The two serve different jobs: dashboards handle ongoing monitoring; Claude Code handles interpretation and reporting.