Tabellen mit Claude Code automatisieren: CSV, Google Sheets API und Apps Script

Tabellenautomatisierung wirkt klein, berührt aber oft Umsatz, Anfragen, Werbekosten, Rechnungen und Content-KPIs. Wenn eine Importregel falsch ist, sieht das Team nicht nur eine fehlende Zeile, sondern falsche Umsätze, falsche Prioritäten und falsche Marketingentscheidungen.

Claude Code ist nützlich, weil es im Repository arbeitet. Es kann ein CSV-Auswertungsskript, ein Google-Sheets-API-Skript, eine Apps-Script-Automation und eine kurze Verifikation mit Dateien, Befehlen und Restrisiken liefern. Genau diese Nachvollziehbarkeit macht aus einem schnellen Helfer einen brauchbaren Betriebsprozess.

Dieser Leitfaden startet lokal mit CSV, schreibt danach Leads in Google Sheets und klassifiziert schließlich Anfragen mit Apps Script. Für den Arbeitsrahmen passen die Claude Code Produktivitätstipps und der Verification-Receipt-Workflow. Offizielle Quellen sind Claude Code docs, Claude Code CLI usage, Google Sheets API Node.js quickstart, Apps Script Sheets guide und SheetJS docs.

Erst die Datengrenze festlegen

Die erste Entscheidung ist nicht die Library. Entscheide zuerst, welche Tabelle die Wahrheit enthält. Wenn derselbe Betrag in CSV, Google Sheet, CRM und Buchhaltung geändert werden kann, beschleunigt Automatisierung nur das Durcheinander. Trenne Eingabe, bereinigte Zwischenschicht und Bericht.

Ebene	Zweck	Beispiel	Aufgabe für Claude Code
Raw	Unveränderte Eingabe	Formulare, Zahlungs-CSV, Anzeigenexport	Import, Validierung, Fehlerzeilen
Clean	Typisierte und normalisierte Daten	Datum, Betrag, Status	Normalisierung, Dedupe, Pflichtspalten
Report	Ausgabe für Menschen	Monatsumsatz, Lead-Priorität, KPI	Summen, Chart-CSV, Benachrichtigung

Ein häufiger Fehler ist, direkt in den Report-Tab zu schreiben. Dort gibt es Farben, Formeln, Notizen, eingefrorene Zeilen und Layout für Menschen. Maschinen brauchen stabile Header und append-only Zeilen. Schreibe in Raw oder Clean und erzeuge Reports mit Formeln, Pivot, Looker Studio oder einem separaten Skript.

Beispiel 1: Sales-CSV monatlich auswerten

Beginne ohne Google-Zugangsdaten. So kann Claude Code eine lokal prüfbare Grundlage erzeugen.

Erstelle data/sales.csv.

date,channel,product,amount,status
2026-05-01,organic,Claude Code Cheatsheet,0,won
2026-05-02,gumroad,Prompt Template Pack,2980,won
2026-05-08,consultation,Team Workshop,120000,won
2026-05-11,gumroad,Prompt Template Pack,2980,refunded
2026-06-01,organic,Claude Code Cheatsheet,0,won
2026-06-02,consultation,Implementation Review,80000,won

Speichere scripts/summarize-sales.mjs.

import { mkdir, readFile, writeFile } from "node:fs/promises";
import path from "node:path";

const inputPath = process.argv[2] ?? "data/sales.csv";
const outputPath = process.argv[3] ?? "out/monthly-summary.csv";

function parseCsvLine(line) {
  const cells = [];
  let current = "";
  let inQuotes = false;

  for (let index = 0; index < line.length; index += 1) {
    const char = line[index];
    const next = line[index + 1];

    if (char === '"' && inQuotes && next === '"') {
      current += '"';
      index += 1;
      continue;
    }

    if (char === '"') {
      inQuotes = !inQuotes;
      continue;
    }

    if (char === "," && !inQuotes) {
      cells.push(current.trim());
      current = "";
      continue;
    }

    current += char;
  }

  cells.push(current.trim());
  return cells;
}

function parseCsv(source) {
  const lines = source.trim().split(/\r?\n/).filter(Boolean);
  const headers = parseCsvLine(lines[0]);

  return lines.slice(1).map((line) => {
    const cells = parseCsvLine(line);
    return Object.fromEntries(headers.map((header, index) => [header, cells[index] ?? ""]));
  });
}

function toMonth(dateValue) {
  const date = new Date(`${dateValue}T00:00:00Z`);
  if (Number.isNaN(date.getTime())) {
    throw new Error(`Invalid date: ${dateValue}`);
  }
  return dateValue.slice(0, 7);
}

const rows = parseCsv(await readFile(inputPath, "utf8"));
const summary = new Map();

for (const row of rows) {
  if (row.status !== "won") continue;

  const amount = Number(row.amount);
  if (!Number.isFinite(amount)) {
    throw new Error(`Invalid amount: ${JSON.stringify(row)}`);
  }

  const key = `${toMonth(row.date)},${row.channel}`;
  const current = summary.get(key) ?? { month: toMonth(row.date), channel: row.channel, deals: 0, revenue: 0 };
  current.deals += 1;
  current.revenue += amount;
  summary.set(key, current);
}

const output = [
  "month,channel,deals,revenue",
  ...[...summary.values()]
    .sort((a, b) => `${a.month}:${a.channel}`.localeCompare(`${b.month}:${b.channel}`))
    .map((row) => `${row.month},${row.channel},${row.deals},${row.revenue}`),
].join("\n");

await mkdir(path.dirname(outputPath), { recursive: true });
await writeFile(outputPath, `${output}\n`, "utf8");

console.log(`Wrote ${outputPath} (${summary.size} groups)`);

Ausführen:

mkdir -p data out scripts
node scripts/summarize-sales.mjs data/sales.csv out/monthly-summary.csv
cat out/monthly-summary.csv

Wichtig ist, bei schlechten Daten sichtbar zu scheitern. Leere Beträge, ungültige Daten und unerwartete Statuswerte dürfen nicht still als null zählen. Danach kann Claude Code Zeilennummern, eine Reject-Datei und Tests für Refunds ergänzen.

Beispiel 2: Leads mit Google Sheets API anhängen

Für Teams ist ein Service Account meist besser auditierbar als persönliches OAuth. Aktiviere Sheets API in Google Cloud, erstelle einen JSON-Key, teile die Tabelle mit der Service-Account-Mail und lege einen Raw-Tab mit createdAt,source,subject,amount,status an.

npm install googleapis
export GOOGLE_APPLICATION_CREDENTIALS="$PWD/service-account.json"
export SHEET_ID="your-google-sheet-id"

Erstelle scripts/append-lead-to-sheet.mjs.

import { google } from "googleapis";

const { GOOGLE_APPLICATION_CREDENTIALS, SHEET_ID } = process.env;

if (!GOOGLE_APPLICATION_CREDENTIALS) {
  throw new Error("GOOGLE_APPLICATION_CREDENTIALS is required");
}

if (!SHEET_ID) {
  throw new Error("SHEET_ID is required");
}

const auth = new google.auth.GoogleAuth({
  keyFile: GOOGLE_APPLICATION_CREDENTIALS,
  scopes: ["https://www.googleapis.com/auth/spreadsheets"],
});

const sheets = google.sheets({ version: "v4", auth });

const source = process.argv[2] ?? "web";
const subject = process.argv[3] ?? "Claude Code consultation";
const amount = Number(process.argv[4] ?? 0);

if (!Number.isFinite(amount)) {
  throw new Error(`Invalid amount: ${process.argv[4]}`);
}

await sheets.spreadsheets.values.append({
  spreadsheetId: SHEET_ID,
  range: "Raw!A:E",
  valueInputOption: "USER_ENTERED",
  insertDataOption: "INSERT_ROWS",
  requestBody: {
    values: [[new Date().toISOString(), source, subject, amount, "new"]],
  },
});

console.log("Appended lead row");

Beispiel:

node scripts/append-lead-to-sheet.mjs newsletter "Spreadsheet automation review" 50000

Wenn Claude Code das Skript bearbeitet, sollen Umgebungsvariablen, Zielbereich, Spaltenreihenfolge und Secret-Regeln erhalten bleiben. service-account.json gehört nicht in Git, Tickets, Dokumente oder Prompts.

Beispiel 3: Sales und Anfragen mit Apps Script klassifizieren

Apps Script ist sinnvoll, wenn der Workflow in Google Workspace bleibt. Es reagiert auf Formularübermittlungen, schreibt in Sheets und versendet Mail ohne eigenen Server. Prüfe aber Laufzeit, Trigger, Berechtigungen und Quoten. Für Volumenbetrieb siehe Apps Script quotas.

Füge den Code in den Apps-Script-Editor ein und richte einen installierbaren Formular-Trigger für onFormSubmit ein.

const SETTINGS = {
  sheetName: "Leads",
  notifyTo: "sales@example.com",
  minAmountForHighPriority: 100000,
};

function onOpen() {
  SpreadsheetApp.getUi()
    .createMenu("Lead Ops")
    .addItem("Rebuild lead status", "rebuildLeadStatus")
    .addToUi();
}

function onFormSubmit(event) {
  const spreadsheet = SpreadsheetApp.getActiveSpreadsheet();
  const sheet = spreadsheet.getSheetByName(SETTINGS.sheetName) || spreadsheet.insertSheet(SETTINGS.sheetName);
  ensureHeader_(sheet);

  const values = event && event.namedValues ? event.namedValues : {};
  const company = first_(values, "Company");
  const email = first_(values, "Email");
  const plan = first_(values, "Plan");
  const budget = Number(first_(values, "Budget") || 0);
  const priority = classifyLead_(plan, budget);

  sheet.appendRow([new Date(), company, email, plan, budget, priority, "new"]);

  if (priority === "high") {
    MailApp.sendEmail({
      to: SETTINGS.notifyTo,
      subject: `High priority lead: ${company}`,
      body: `Company: ${company}\nEmail: ${email}\nPlan: ${plan}\nBudget: ${budget}`,
    });
  }
}

function rebuildLeadStatus() {
  const sheet = SpreadsheetApp.getActiveSpreadsheet().getSheetByName(SETTINGS.sheetName);
  if (!sheet) throw new Error(`Sheet not found: ${SETTINGS.sheetName}`);
  ensureHeader_(sheet);

  const values = sheet.getDataRange().getValues();
  for (let rowIndex = 1; rowIndex < values.length; rowIndex += 1) {
    const row = values[rowIndex];
    const plan = String(row[3] || "");
    const budget = Number(row[4] || 0);
    const priority = classifyLead_(plan, budget);
    sheet.getRange(rowIndex + 1, 6).setValue(priority);
  }
}

function ensureHeader_(sheet) {
  const header = ["createdAt", "company", "email", "plan", "budget", "priority", "status"];
  const current = sheet.getRange(1, 1, 1, header.length).getValues()[0];
  if (current.join("") === "") {
    sheet.getRange(1, 1, 1, header.length).setValues([header]);
    sheet.setFrozenRows(1);
  }
}

function classifyLead_(plan, budget) {
  const normalizedPlan = String(plan).toLowerCase();
  if (budget >= SETTINGS.minAmountForHighPriority || normalizedPlan.includes("team")) {
    return "high";
  }
  if (budget >= 30000) {
    return "medium";
  }
  return "low";
}

function first_(namedValues, key) {
  const value = namedValues[key];
  return Array.isArray(value) ? value[0] || "" : "";
}

Passe die Feldnamen an dein Formular an. Wenn das Formular deutsch ist, ersetze Company, Plan und Budget durch die echten Labels und verhindere, dass personenbezogene Daten geloggt werden.

Prompt für Claude Code

Ein guter Prompt ist eng und prüfbar.

You are working on spreadsheet automation for this repository.

Goal:
- Import sales CSV rows from data/sales.csv.
- Write a monthly summary to out/monthly-summary.csv.
- Add a Google Sheets append script for the Raw tab.

Scope:
- You may edit scripts/summarize-sales.mjs and scripts/append-lead-to-sheet.mjs.
- You may add small tests or sample CSV files if needed.
- Do not edit content files, product links, analytics, or deployment settings.

Rules:
- Do not commit credentials.
- Use environment variables for SHEET_ID and GOOGLE_APPLICATION_CREDENTIALS.
- Fail loudly on invalid dates, invalid amounts, and missing required columns.
- Keep the code copy-paste runnable with Node.js 20 or later.

Verification:
- Run node --check on every script you edit.
- Run the CSV summary against data/sales.csv.
- For Google Sheets API, verify syntax locally and list the manual credential checks.
- Return changed files, commands run, output summary, and remaining risks.

Verifikation:

node --check scripts/summarize-sales.mjs
node scripts/summarize-sales.mjs data/sales.csv out/monthly-summary.csv
node --check scripts/append-lead-to-sheet.mjs
git diff -- scripts/summarize-sales.mjs scripts/append-lead-to-sheet.mjs

Im Team gehört der stabile Teil nach CLAUDE.md und in die Claude Code Berechtigungsanleitung.

Praktische Anwendungsfälle

Der erste Fall ist monatliches Revenue Reporting. Gumroad, Stripe, manuelle Rechnungen und kostenlose PDF-Registrierungen werden zusammengeführt. Refunds zählen nicht als Umsatz, kostenlose Leads zählen als Volumen, Produktnamen werden normalisiert.

Der zweite Fall ist Lead-Priorisierung. Budget, Teamgröße, Plan und bestehende Kundendomains können Regeln sein. Diese Regeln müssen erklärbar bleiben. “Budget über 100000 Yen oder Team-Plan” ist überprüfbar, “wirkt gut” nicht.

Der dritte Fall ist Artikel- und Anzeigen-KPI. Eine Tabelle kann Slug, Veröffentlichungsdatum, Suchklicks, CTA-Klicks, Produktklicks und Formularstarts enthalten. Für Eventnamen passt die Analytics-Anleitung mit Claude Code.

Der vierte Fall ist Rechnungsprüfung. Vergleiche Lieferlogs mit Rechnungs-CSV und schreibe nur Abweichungen in ein Review-Sheet. Automatisches Versenden kommt später.

Fehler und Fallen

Der größte Fehler sind instabile Header. Wenn Amount, amount und Umsatz gemischt werden, kann das Skript erfolgreich laufen und trotzdem Zeilen überspringen. Pflichtspalten müssen geprüft werden.

Der zweite Fehler ist Sheets als Datenbank zu verwenden. Sheets eignet sich für Zusammenarbeit und Kontrolle, nicht für Transaktionen, Locks, kanonische Berechtigungen und Massenschreiben. Zahlungen und Zugriffsrechte bleiben in der Anwendungsdatenbank.

Der dritte Fehler ist Secret-Leakage. Service-Account-JSON darf nie in Prompts, Tickets, Dokumente oder Commits. Claude Code soll Secrets nicht lesen, ausgeben oder committen.

Der vierte Fehler sind vergessene Apps-Script-Trigger. Code im Editor reicht nicht. Prüfe installierbaren Trigger, Ausführungsnutzer, Erstautorisierung, Mailquote und Fehlerbenachrichtigung.

Der fünfte Fehler ist nur die Summe zu lesen. Jeder Report braucht gelesene Zeilen, ausgeschlossene Zeilen, Fehleranzahl und letzte Aktualisierung.

CTA: Vom Skript zum Betrieb

Zuverlässigkeit entsteht durch wiederholbare Prompts, Berechtigungen und Verifikation. Starte mit dem kostenlosen Claude Code Cheatsheet für Befehle und Review-Gewohnheiten. Wiederverwendbare Prompts und CLAUDE.md-Vorlagen findest du bei den ClaudeCodeLab Produkten.

Wenn ein Team Sales, Leads, Ads oder Rechnungen in Sheets betreibt, sollten Credential-Grenzen und manuelle Freigaben vor weiterer Automatisierung feststehen. Dafür gibt es Claude Code Training und Beratung.

Ergebnis aus der Praxis

In Masas Ablauf war nicht die Sheets API der erste große Gewinn, sondern feste CSV-Header, Ausschlussregeln und Fehlerverhalten. Apps Script war für Lead-Klassifikation gut, aber unscharfe Benachrichtigungsregeln erzeugten zu viele Mails. Stabil wurde es, als Raw, Clean und Report klar getrennt waren und Claude Code kleine, verifizierte Teile umsetzte.