Google Ads API: Einführung für Entwickler und Agenturen

Die Google Ads API ist die leistungsstärkste Schnittstelle für programmatischen Zugriff auf Google Ads. Während die Weboberfläche und Scripts für die meisten Nutzer ausreichen, eröffnet die API neue Möglichkeiten für große Agenturen, Tool-Entwickler und Unternehmen mit komplexen Automatisierungsanforderungen. In diesem Guide erklären wir, was die API ist, wie Sie Zugang erhalten und welche Use Cases sie besonders wertvoll machen.

Was ist die Google Ads API?

Die Google Ads API ist eine REST-basierte Programmierschnittstelle, die vollständigen Zugriff auf Google Ads Funktionalität bietet. Sie ermöglicht das Erstellen, Lesen, Aktualisieren und Löschen von Kampagnen, Keywords, Anzeigen und allen anderen Entitäten programmatisch.

Definition und Funktionsumfang

Was ist eine API? Eine Application Programming Interface ermöglicht Software-zu-Software-Kommunikation. Statt manueller Aktionen in der Weboberfläche sendet Ihre Anwendung HTTP-Anfragen an Googles Server, die strukturierte Daten zurückgeben oder Änderungen vornehmen.

Funktionsumfang der Google Ads API:

• Vollständiges Kampagnen-Management: Erstellen, bearbeiten, pausieren, löschen
• Reporting und Analytics: Abrufen von Performance-Daten mit flexiblen Queries
• Bidding und Budget-Management: Programmatische Gebotsanpassungen
• Audience Management: Erstellen und verwalten von Zielgruppen
• Asset-Management: Upload und Verwaltung von Bildern, Videos und anderen Assets
• Bulk-Operationen: Massive Änderungen an tausenden Entitäten gleichzeitig
• Echtzeit-Zugriff: Keine Wartezeiten wie bei manchen Reporting-Tools

API-Versionen: Google veröffentlicht regelmäßig neue API-Versionen mit erweiterten Features. 2026 ist Version 16 aktuell, mit Backwards-Kompatibilität für einige ältere Versionen.

API vs. Scripts vs. Editor

Google bietet mehrere Wege zum programmatischen Zugriff. Wann nutzen Sie welchen?

Google Ads API:

• Beste für: Custom-Tool-Entwicklung, große Agenturen, komplexe Integrationen
• Vorteile: Vollständiger Funktionsumfang, keine Laufzeit-Limits, externe Hosting-Möglichkeit
• Nachteile: Komplexer Setup, Developer Token erforderlich, steile Lernkurve
• Use Case: Eigenes Bid-Management-Tool, Cross-Platform-Dashboard, White-Label-Lösung

Google Ads Scripts:

• Beste für: Automatisierung in einzelnen Konten, kleine bis mittlere Agenturen
• Vorteile: Einfacher Start, läuft auf Google-Servern, integriert in Google Ads UI
• Nachteile: 30-Minuten-Laufzeit-Limit, JavaScript-only, weniger Funktionen als API
• Use Case: Tägliche Reports, Budget-Monitoring, einfache Optimierungen

Google Ads Editor:

• Beste für: Bulk-Bearbeitung durch Menschen, Offline-Arbeit
• Vorteile: Keine Programmierung, Desktop-App, mächtige Bulk-Funktionen
• Nachteile: Keine Automatisierung, manuelle Nutzung erforderlich
• Use Case: Große Account-Umstrukturierungen, Kampagnen-Duplikation

Entscheidungshilfe: Für die meisten Automatisierungs-Bedürfnisse starten Sie mit Scripts. Wenn Sie an deren Grenzen stoßen (Laufzeit, Funktionalität) oder ein kommerzielles Tool entwickeln, wechseln Sie zur API.

API-Zugang beantragen

Der Zugang zur Google Ads API erfordert einen Bewerbungsprozess. Google kontrolliert den Zugang, um Missbrauch zu verhindern.

Voraussetzungen

Bevor Sie Zugang beantragen, stellen Sie sicher:

• Google Ads Konto: Sie benötigen ein aktives Google Ads Konto (kann auch Test-Konto sein)
• Developer-Skills: Grundkenntnisse in mindestens einer Programmiersprache (Python, Java, PHP, etc.)
• Use Case: Klare Vorstellung, wofür Sie die API nutzen möchten
• Compliance-Verständnis: Kenntnisse der API Terms & Conditions

Developer Token beantragen

Der Developer Token ist Ihr Zugangsschlüssel zur API:

1. Melden Sie sich bei Google Ads an (bevorzugt in einem Manager-Konto/MCC, wenn Sie eines haben)
2. Klicken Sie auf "Tools und Einstellungen" → "Setup" → "API Center"
3. Klicken Sie auf "Developer Token beantragen"
4. Füllen Sie das Antragsformular aus:
   • Firmenname und Website
   • Beschreibung Ihres Use Cases: Seien Sie spezifisch. "Automatisierung" ist zu vague. "Custom Reporting Dashboard für 50 Agentur-Kunden" ist besser.
   • Erwartetes Request-Volumen: Schätzen Sie realistisch
5. Stimmen Sie den Terms zu und senden Sie die Anfrage

Bearbeitungszeit: Google prüft Anträge üblicherweise innerhalb von 1-5 Werktagen. In manchen Fällen kann es länger dauern oder Google fragt nach zusätzlichen Informationen.

OAuth 2.0 einrichten

Zusätzlich zum Developer Token benötigen Sie OAuth 2.0 Credentials für die Authentifizierung:

1. Besuchen Sie die Google Cloud Console

2. Erstellen Sie ein neues Projekt (oder wählen Sie ein bestehendes)

3. Aktivieren Sie die "Google Ads API" für Ihr Projekt:

   • "APIs & Services" → "Library" → Suchen Sie "Google Ads API" → "Enable"

4. Erstellen Sie OAuth 2.0 Credentials:

   • "APIs & Services" → "Credentials" → "Create Credentials" → "OAuth client ID"
   • Application type: "Desktop app" (für lokale Entwicklung) oder "Web application" (für hosted Apps)
   • Notieren Sie Client ID und Client Secret

5. Autorisieren Sie Ihre Anwendung:

   • Nutzen Sie Google's OAuth 2.0 Flow, um ein Refresh Token zu erhalten
   • Die Client Libraries bieten Helper-Functions für diesen Prozess

Sicherheit: Behandeln Sie Client Secret und Refresh Token wie Passwörter. Speichern Sie sie sicher und committen Sie sie nie in öffentliche Repositories.

Zugangslevels (Basic vs. Standard)

Google vergibt Developer Tokens in zwei Levels:

Basic Access (Test-Level):

• Automatisch vergeben während der Prüfung
• Funktioniert nur mit Test-Konten und dem Konto, das den Token beantragt hat
• Limitierte API-Anfragen (wenige tausend pro Tag)
• Keine Produktions-Nutzung möglich
• Zweck: Entwicklung und Testing

Standard Access (Production-Level):

• Vergeben nach erfolgreicher Prüfung durch Google
• Funktioniert mit allen Google Ads Konten, zu denen Sie Zugriff haben
• Höhere Rate Limits (Millionen Anfragen pro Tag möglich)
• Für Live-Produktions-Nutzung
• Voraussetzung: Nachweisbare legitime Use Cases, Compliance mit Policies

Upgrade-Prozess: Nach initialer Entwicklung mit Basic Access bewerben Sie sich für Standard Access. Google prüft Ihre Anwendung und Use Cases. Dieser Prozess kann mehrere Wochen dauern und erfordert detaillierte Dokumentation Ihrer Implementierung.

Erste Schritte mit der API

Nachdem Sie Zugang haben, beginnen Sie mit der Implementierung. Google bietet Client Libraries für alle gängigen Programmiersprachen.

Client Libraries installieren

Google pflegt offizielle Libraries für:

Python (empfohlen für Einsteiger):

pip install google-ads

Java:

# Maven Dependency
<dependency>
  <groupId>com.google.api-ads</groupId>
  <artifactId>google-ads</artifactId>
  <version>LATEST_VERSION</version>
</dependency>

PHP:

composer require googleads/google-ads-php

Ruby:

gem install google-ads-googleads

.NET:

Install-Package Google.Ads.GoogleAds

Empfehlung: Python ist die beliebteste Wahl für Google Ads API-Entwicklung. Die Library ist gut dokumentiert, die Community groß, und Python eignet sich hervorragend für Daten-Verarbeitung.

Authentifizierung

Bevor Sie API-Calls machen können, konfigurieren Sie die Authentifizierung. Erstellen Sie eine google-ads.yaml Konfigurationsdatei:

# Google Ads API Configuration
developer_token: INSERT_DEVELOPER_TOKEN_HERE
client_id: INSERT_OAUTH2_CLIENT_ID_HERE
client_secret: INSERT_OAUTH2_CLIENT_SECRET_HERE
refresh_token: INSERT_REFRESH_TOKEN_HERE
login_customer_id: INSERT_LOGIN_CUSTOMER_ID_HERE

Parameter-Erklärung:

• developer_token: Ihr Developer Token aus dem API Center
• client_id und client_secret: OAuth Credentials aus Google Cloud Console
• refresh_token: OAuth Refresh Token (erhalten durch einmaligen Authorization Flow)
• login_customer_id: Die Customer ID des Manager-Kontos, falls Sie eines nutzen (optional)

Die Client Libraries lesen diese Datei automatisch.

Erste Abfrage durchführen

Ein einfaches Python-Beispiel zum Abrufen von Kampagnen:

from google.ads.googleads.client import GoogleAdsClient

# Client initialisieren (liest google-ads.yaml)
client = GoogleAdsClient.load_from_storage("google-ads.yaml")

# Customer ID des Kontos, das Sie abfragen möchten
customer_id = "1234567890"  # Ohne Bindestriche

# Google Ads Service abrufen
ga_service = client.get_service("GoogleAdsService")

# Query für Kampagnen
query = """
    SELECT
        campaign.id,
        campaign.name,
        campaign.status,
        metrics.impressions,
        metrics.clicks,
        metrics.cost_micros
    FROM campaign
    WHERE segments.date DURING LAST_30_DAYS
    ORDER BY metrics.impressions DESC
    LIMIT 10
"""

# Query ausführen
response = ga_service.search(customer_id=customer_id, query=query)

# Ergebnisse ausgeben
print("Top 10 Kampagnen nach Impressions:")
for row in response:
    campaign = row.campaign
    metrics = row.metrics

    cost_eur = metrics.cost_micros / 1_000_000  # Micros zu EUR

    print(f"Kampagne: {campaign.name}")
    print(f"  Status: {campaign.status.name}")
    print(f"  Impressions: {metrics.impressions}")
    print(f"  Clicks: {metrics.clicks}")
    print(f"  Cost: {cost_eur:.2f} EUR")
    print()

Was passiert hier?

1. Client wird initialisiert mit Credentials
2. GoogleAdsService wird geladen (der Haupt-Service für Queries)
3. Eine GAQL-Query (Google Ads Query Language) definiert, welche Daten abgerufen werden
4. Query wird ausgeführt
5. Ergebnisse werden iteriert und ausgegeben

Erfolgskriterium: Wenn dieses Script ohne Fehler läuft und Ihre Kampagnendaten zeigt, funktioniert Ihr API-Setup korrekt.

API Use Cases

Die API glänzt bei spezifischen Anwendungsfällen, die mit Standard-Tools schwierig oder unmöglich sind.

Kampagnen-Management automatisieren

Szenario: Sie verwalten hunderte Kampagnen mit ähnlichen Strukturen und möchten sie synchron halten.

Lösung mit API:

• Template-basierte Kampagnenerstellung
• Bulk-Updates über alle Kampagnen (z.B. neue negative Keywords in 500 Kampagnen)
• Regelbasierte Anpassungen basierend auf externen Daten (Lagerbestände, Produktpreise)

Beispiel: Ein E-Commerce-Unternehmen mit 1.000 Produkten erstellt automatisch eine Shopping-Kampagne für jedes Produkt, passt Budgets basierend auf Lagerverfügbarkeit an und pausiert Kampagnen für ausverkaufte Artikel – alles in Echtzeit über die API.

Custom Reporting Dashboards

Szenario: Ihre Stakeholder brauchen spezifische Reports, die Google Ads nicht nativ bietet.

Lösung mit API:

• Abrufen von Daten aus Google Ads und anderen Quellen
• Kombination mit CRM-, ERP- oder Warehouse-Daten
• Visualisierung in Custom-Dashboards (React, Vue, etc.)
• Echtzeit-Updates

Beispiel: Ein Dashboard zeigt Google Ads Performance kombiniert mit Offline-Verkaufsdaten aus Ihrem POS-System, um echten ROAS inkl. Offline-Conversions zu berechnen.

Bidding Tools entwickeln

Szenario: Sie möchten Custom Bidding-Strategien implementieren, die komplexer sind als Googles Smart Bidding.

Lösung mit API:

• Abrufen von Keyword- oder Placement-Performance
• Eigene Algorithmen für Gebotsberechnung
• Automatische Gebotsanpassungen via API
• Integration externer Faktoren (Wetter, Events, Inventar)

Beispiel: Ein Reiseunternehmen passt Gebote für Hotels basierend auf aktueller Auslastung an – bei niedriger Auslastung werden Gebote erhöht, um Zimmer zu füllen.

Cross-Platform Datenintegration

Szenario: Sie nutzen mehrere Werbeplattformen und möchten einheitliches Reporting.

Lösung mit API:

• Daten von Google Ads, Facebook, LinkedIn, etc. über deren APIs abrufen
• Normalisierung und Kombination in einer Datenbank
• Einheitliche Metriken und Vergleiche über Plattformen hinweg

Beispiel: Ein Agency-Dashboard zeigt aggregierte Performance über Google Ads, Facebook Ads und LinkedIn Ads für alle Kunden in einer einheitlichen Oberfläche.

Bulk-Operationen

Szenario: Sie müssen tausende Änderungen schnell durchführen.

Lösung mit API:

• Batch-Requests für effiziente Bulk-Operations
• Parallelisierung für maximale Geschwindigkeit
• Fehlerbehandlung und Retry-Logik

Beispiel: Ein Rebranding erfordert das Ändern von URLs in 10.000 Anzeigen. Via API mit Batch-Requests dauert dies Minuten statt Tage.

Python-Beispiel: Kampagnen abrufen

Ein erweitertes Beispiel mit Fehlerbehandlung und Formatierung:

from google.ads.googleads.client import GoogleAdsClient
from google.ads.googleads.errors import GoogleAdsException
import sys

def get_campaigns(client, customer_id):
    """Ruft Kampagnen-Performance für die letzten 30 Tage ab."""
    ga_service = client.get_service("GoogleAdsService")

    query = """
        SELECT
            campaign.id,
            campaign.name,
            campaign.status,
            campaign.advertising_channel_type,
            campaign_budget.amount_micros,
            metrics.impressions,
            metrics.clicks,
            metrics.ctr,
            metrics.cost_micros,
            metrics.conversions,
            metrics.cost_per_conversion
        FROM campaign
        WHERE segments.date DURING LAST_30_DAYS
            AND campaign.status != 'REMOVED'
        ORDER BY metrics.impressions DESC
        LIMIT 50
    """

    try:
        response = ga_service.search_stream(customer_id=customer_id, query=query)

        print(f"{'Kampagne':<40} {'Typ':<15} {'Budget (EUR)':<15} {'Impressions':<12} {'Klicks':<10} {'CTR':<8} {'Kosten (EUR)':<12} {'Conv.':<8}")
        print("-" * 140)

        for batch in response:
            for row in batch.results:
                campaign = row.campaign
                metrics = row.metrics
                budget = row.campaign_budget

                # Konvertierungen
                budget_eur = budget.amount_micros / 1_000_000 if budget.amount_micros else 0
                cost_eur = metrics.cost_micros / 1_000_000
                ctr_percent = metrics.ctr * 100 if metrics.ctr else 0

                print(f"{campaign.name:<40} "
                      f"{campaign.advertising_channel_type.name:<15} "
                      f"{budget_eur:<15.2f} "
                      f"{metrics.impressions:<12} "
                      f"{metrics.clicks:<10} "
                      f"{ctr_percent:<8.2f} "
                      f"{cost_eur:<12.2f} "
                      f"{metrics.conversions:<8.1f}")

    except GoogleAdsException as ex:
        print(f"API-Fehler aufgetreten:")
        print(f"  Request ID: {ex.request_id}")
        for error in ex.failure.errors:
            print(f"  Error: {error.error_code.name}")
            print(f"  Message: {error.message}")
        sys.exit(1)

if __name__ == "__main__":
    # Client initialisieren
    client = GoogleAdsClient.load_from_storage("google-ads.yaml")

    # Customer ID (ohne Bindestriche)
    customer_id = "1234567890"

    get_campaigns(client, customer_id)

Erklärung:

• search_stream wird verwendet statt search für bessere Performance bei vielen Resultaten
• Umfassende Fehlerbehandlung für API-Errors
• Formatierte Tabellen-Ausgabe für Lesbarkeit
• Conversion von Micros (API-Standard) zu EUR

API-Limits und Best Practices

Die API hat Limits, um Missbrauch zu verhindern und Stabilität zu gewährleisten.

Rate Limits verstehen

Rate Limits:

• Basic Access: ~15.000 Requests pro Tag
• Standard Access: Höhere Limits, variabel je nach Nutzung
• Per-Request-Objekt-Limits: Max. 10.000 Operationen pro Batch-Request

Limit-Überschreitung: Bei Überschreitung erhalten Sie HTTP 429 (Too Many Requests) Errors. Ihre Anwendung sollte diese abfangen und mit Exponential Backoff retries implementieren.

Tipp: Nutzen Sie search_stream statt search für große Datenmengen – dies ist effizienter und count nicht gegen Paging-Limits.

Batch Requests nutzen

Batch Requests sind essentiell für Effizienz:

Single Requests (ineffizient):

# 1000 Keywords einzeln pausieren = 1000 API Calls
for keyword in keywords:
    keyword.pause()

Batch Requests (effizient):

# 1000 Keywords in batches pausieren = ~10 API Calls
operations = []
for keyword in keywords:
    operation = client.get_type("KeywordOperation")
    operation.update = keyword
    operation.update_mask = client.get_type("FieldMask")(paths=["status"])
    operations.append(operation)

# Batch request mit bis zu 10.000 operations
service.mutate_keywords(customer_id=customer_id, operations=operations)

Vorteile: Dramatisch reduzierte API-Calls, schnellere Ausführung, effizientere Quota-Nutzung.

Fehlerbehandlung

Robuste Fehlerbehandlung ist kritisch:

from google.api_core.exceptions import RetryError
from google.ads.googleads.errors import GoogleAdsException
import time

def api_call_with_retry(func, max_retries=3):
    """Wrapper für API-Calls mit Retry-Logik."""
    for attempt in range(max_retries):
        try:
            return func()
        except GoogleAdsException as ex:
            # Bestimmte Fehler sollten nicht retried werden
            if ex.failure.errors[0].error_code.authentication_error:
                raise  # Auth-Fehler sind permanent

            if attempt < max_retries - 1:
                wait_time = 2 ** attempt  # Exponential backoff
                print(f"Retry in {wait_time} Sekunden...")
                time.sleep(wait_time)
            else:
                raise

# Nutzung
result = api_call_with_retry(lambda: get_campaigns(client, customer_id))

Best Practices:

• Implementieren Sie Exponential Backoff für transiente Fehler
• Loggen Sie alle API-Errors mit Request IDs für Debugging
• Unterscheiden Sie permanente (Auth, Permission) und transiente (Rate Limit, Server) Fehler

API vs. Alternativen

Wann sollten Sie die API nutzen und wann reichen Alternativen?

Wann API?

Nutzen Sie die API wenn:

• Sie ein kommerzielles Tool oder SaaS-Produkt entwickeln
• Sie sehr große Konten verwalten (tausende Kampagnen)
• Sie komplexe Custom-Logik benötigen
• Sie Cross-Platform-Integrationen bauen
• Scripts' 30-Minuten-Limit zu restriktiv ist
• Sie Echtzeit-Daten und -Updates benötigen

Wann Scripts?

Nutzen Sie Scripts wenn:

• Sie Automatisierung für wenige Konten brauchen
• Ihr Use Case in 30 Minuten ausführbar ist
• Sie keine externe Hosting-Infrastruktur verwalten möchten
• Sie schnell starten möchten ohne aufwändigen Setup
• JavaScript für Ihre Zwecke ausreichend ist

Wann Third-Party Tools?

Nutzen Sie Third-Party Tools (wie Optmyzr, Adalysis) wenn:

• Ihr Use Case von existierenden Tools gut abgedeckt wird
• Sie keine Entwickler-Ressourcen haben
• Sie schnell starten möchten ohne eigene Entwicklung
• Support und Updates wichtig sind

Entscheidungsmatrix:

| Kriterium | API | Scripts | Third-Party | |-----------|-----|---------|-------------| | Setup-Aufwand | Hoch | Niedrig | Sehr niedrig | | Flexibilität | Maximal | Mittel | Begrenzt | | Kosten | Dev-Zeit | Keine | Abo-Gebühren | | Wartung | Sie | Google | Anbieter | | Laufzeit-Limits | Keine | 30 Min | Tool-abhängig |

Häufige Fragen

Ist die Google Ads API kostenlos? Ja, die Nutzung der API selbst ist kostenlos. Sie zahlen nur für Ihre Google Ads Werbung. Allerdings entstehen Kosten für Entwicklung, Hosting Ihrer Anwendung und eventuell Cloud-Infrastruktur.

Wie lange dauert es, API-Zugang zu bekommen? Basic Access (Test-Token) wird üblicherweise innerhalb von 1-5 Werktagen gewährt. Standard Access (Production-Token) kann mehrere Wochen bis Monate dauern, je nach Use Case und Vollständigkeit Ihrer Bewerbung.

Kann ich die API ohne Programmierkenntnisse nutzen? Nein. Die API erfordert Programmierung in einer unterstützten Sprache. Wenn Sie keine Entwickler-Skills haben, sind Google Ads Scripts (einfacher) oder Third-Party Tools (keine Programmierung) bessere Optionen.

Welche Programmiersprache ist am besten? Python ist die beliebteste Wahl für Google Ads API-Entwicklung: Gute Dokumentation, große Community, ideal für Datenverarbeitung. Java ist gut für Enterprise-Umgebungen. PHP für WordPress/Website-Integrationen. Wählen Sie die Sprache, mit der Ihr Team vertraut ist.

Was passiert, wenn mein Standard Access abgelehnt wird? Sie können weiter Basic Access nutzen (limitiert auf Test-Konten). Google gibt üblicherweise Feedback, warum die Ablehnung erfolgte. Beheben Sie die genannten Probleme und bewerben Sie sich erneut. Hartnäckigkeit und klare Use-Case-Dokumentation helfen.

Fazit

Die Google Ads API ist das mächtigste Tool für programmatischen Zugriff auf Google Ads – aber auch das komplexeste. Der Aufwand für Setup und Entwicklung lohnt sich für spezifische Use Cases: Tool-Entwicklung, große Agenturen, komplexe Automatisierungen und Cross-Platform-Integrationen.

Für die meisten alltäglichen Automatisierungsaufgaben sind Google Ads Scripts ausreichend und deutlich einfacher. Wenn Sie jedoch an deren Grenzen stoßen oder ein kommerzielles Produkt entwickeln, bietet die API unbegrenzte Möglichkeiten.

Der Einstieg ist steil, aber Google's Client Libraries und umfangreiche Dokumentation erleichtern den Start. Beginnen Sie mit einfachen Queries, lernen Sie GAQL (Google Ads Query Language) und erweitern Sie Ihre Implementierung schrittweise. Die Investition in API-Know-how zahlt sich durch Automatisierungsmöglichkeiten aus, die mit Standard-Google Ads Tools unmöglich wären. Für Bulk-Operationen ohne Programmierung empfehlen wir alternativ den Google Ads Editor.