Zum Hauptinhalt springen
Deutsch— Sprache auswählen
Menü

Automatisierte Wettbewerbsberichte

Lektion 10 von 12 Aktualisiert am 30. Juli 2026 Mittelstufe
Auf dieser Seite
  1. Automatisierung von Wettbewerbsaufklärung
  2. Architektur eines vollständigen Wettbewerbsberichts
  3. Aufbau des Berichtssystems
  4. Strukturierung des Berichts in nutzbares JSON
  5. Vergleich von Zeiträumen zur Erkennung von Änderungen
  6. Planung der wiederkehrenden Ausführung
  7. Best Practices für nutzbare Berichte
  8. Kernaussagen

Automatisierung von Wettbewerbsaufklärung

Ein einmal erstellter Wettbewerbsbericht veraltet innerhalb weniger Tage. Der eigentliche Wert liegt in der Automatisierung: regelmäßig generierte Berichte, die strukturell identisch aufgebaut sind, ermöglichen es Ihnen, Zeiträume zu vergleichen und strategische Verschiebungen Ihrer Wettbewerber zu verfolgen.

In dieser Lektion erfahren Sie, wie Sie ein automatisiertes System zur Wettbewerbsaufklärung aufbauen, das X-Daten und Web-Daten kombiniert.

Architektur eines vollständigen Wettbewerbsberichts

Ein effektiver Marketing-Wettbewerbsbericht deckt fünf Achsen ab, und sein Wert ergibt sich aus deren Überschneidung: Ein Produktlaunch (Achse 3) zeigt sich beispielsweise auch im Publikationsvolumen (Achse 1) und in der öffentlichen Stimmung (Achse 4). Diese Querverweise unterscheiden Intelligenz von einer einfachen Datensammlung – ein Signal, das durch zwei Achsen bestätigt wird, verdient Aufmerksamkeit, ein isoliertes Signal bedarf hingegen meist einer Verifizierung:

1. Aktivität in sozialen Medien

Publikationsvolumen, genutzte Formate, Engagement, Wachstum der Zielgruppe.

2. Content-Strategie

Behandelte Themen, Tonfall, Positionierung, beobachteter Editorial-Kalender.

3. Launches und Ankündigungen

Neue Produkte, Funktionen, Partnerschaften, Veranstaltungen.

4. Öffentliche Wahrnehmung

Stimmung, Beschwerden, Lob, spontane Vergleiche mit anderen Marken.

5. Preisgestaltung und Angebotspositionierung

Preisänderungen, Aktionen, Verpackungen, Sonderangebote.

Aufbau des Berichtssystems

Klasse für Wettbewerbsberichte

from datetime import datetime, timedelta
import json

class RapportConcurrentiel:
    def __init__(self, client, marque_propre, concurrents):
        self.client = client
        self.marque = marque_propre
        self.concurrents = concurrents

    def collecter_donnees_x(self, handles, start, end):
        response = self.client.responses.create(
            model="grok-4.20-0309-reasoning",
            input=f"""Collect and analyze posts
            from these accounts from {start} to {end}.

            Provide for each account:
            - Estimated number of posts
            - Content types (text, image, video, thread)
            - Most engaging posts
            - Main themes covered
            - Observed tone and positioning
            - Detected announcements or launches""",
            tools=[{
                "type": "x_search",
                "allowed_x_handles": handles,
                "from_date": start,
                "to_date": end,
                "enable_image_understanding": True
            }]
        )
        return response.output_text

    def collecter_donnees_web(self, concurrent, start, end):
        response = self.client.responses.create(
            model="grok-4.20-0309-reasoning",
            input=f"""Search for recent news regarding
            {concurrent} between {start} and {end}.

            Focus on:
            - Press releases and news articles
            - Product or service updates
            - Leadership team changes
            - Fundraising or financial results
            - Strategic partnerships""",
            tools=[{
                "type": "web_search",
                "allowed_domains": [
                    "techcrunch.com", "lesechos.fr",
                    "usine-digitale.fr"
                ]
            }]
        )
        return response.output_text

Generierung des zusammengeführten Berichts

    def generer_rapport(self, periode_jours=30):
        end = datetime.now().strftime("%Y-%m-%d")
        start = (datetime.now() - timedelta(
            days=periode_jours)).strftime("%Y-%m-%d")

        sections = {}

        # Datensammlung für jeden Wettbewerber
        for concurrent in self.concurrents:
            handles = concurrent.get("handles", [])
            nom = concurrent["nom"]

            donnees_x = self.collecter_donnees_x(
                handles, start, end
            ) if handles else "No X data"

            donnees_web = self.collecter_donnees_web(
                nom, start, end
            )

            sections[nom] = {
                "x": donnees_x,
                "web": donnees_web
            }

        # Zusammenfassender Vergleich
        rapport_final = self.client.responses.create(
            model="grok-4.20-0309-reasoning",
            input=f"""Compile this monthly competitive report.

            Our brand: {self.marque}
            Period: {start} to {end}

            DATA PER COMPETITOR:
            {json.dumps(sections, ensure_ascii=False, indent=2)}

            Report structure:
            1. EXECUTIVE SUMMARY (5 bullet points max)
            2. COMPARATIVE TABLE (activity, sentiment, innovation)
            3. ANALYSIS PER COMPETITOR (strengths, weaknesses, moves)
            4. IDENTIFIED THREATS (ranked by urgency)
            5. OPPORTUNITIES FOR {self.marque}
            6. STRATEGIC RECOMMENDATIONS (3-5 priority actions)"""
        ).output_text

        return rapport_final

Strukturierung des Berichts in nutzbares JSON

Um ein Dashboard oder eine Datenbank zu versorgen, fordern Sie ein strukturiertes Format an:

    def rapport_json(self, periode_jours=30):
        end = datetime.now().strftime("%Y-%m-%d")
        start = (datetime.now() - timedelta(
            days=periode_jours)).strftime("%Y-%m-%d")

        response = self.client.responses.create(
            model="grok-4.20-0309-reasoning",
            input=f"""Generate a competitive report in JSON.

            Competitors: {json.dumps([c['nom'] for c in self.concurrents])}
            Period: {start} to {end}

            Expected format:
            {{
              "period": "{start} - {end}",
              "competitors": [
                {{
                  "name": "Competitor A",
                  "social_activity": {{
                    "post_volume": 45,
                    "average_engagement": "high",
                    "dominant_formats": ["image", "thread"]
                  }},
                  "public_sentiment": 3.8,
                  "innovations": ["description"],
                  "threats": ["description"],
                  "main_strength": "description",
                  "main_weakness": "description"
                }}
              ],
              "recommendations": ["action 1", "action 2"]
            }}""",
            tools=[
                {"type": "x_search", "from_date": start, "to_date": end},
                {"type": "web_search"}
            ]
        )
        return response.output_text

Vergleich von Zeiträumen zur Erkennung von Änderungen

Der Wert eines automatisierten Systems liegt im zeitlichen Vergleich:

def comparer_rapports(rapport_actuel, rapport_precedent):
    response = client.responses.create(
        model="grok-4.20-0309-reasoning",
        input=f"""Compare these two consecutive
        competitive reports and identify significant changes:

        PREVIOUS REPORT: {rapport_precedent}
        CURRENT REPORT: {rapport_actuel}

        Analysis:
        1. Which competitors changed strategy?
        2. What new threats appeared?
        3. What opportunities opened or closed?
        4. What trends are confirmed or reversing?
        5. Recommended immediate actions."""
    )
    return response.output_text

Planung der wiederkehrenden Ausführung

Integrieren Sie Ihren Bericht in einen Cron-Job oder einen Python-Scheduler:

# Wöchentliche Ausführung
rapport = RapportConcurrentiel(
    client=client,
    marque_propre="Your Brand",
    concurrents=[
        {
            "nom": "Competitor A",
            "handles": ["competitor_a", "competitor_a_fr"]
        },
        {
            "nom": "Competitor B",
            "handles": ["competitor_b"]
        },
        {
            "nom": "Competitor C",
            "handles": ["competitor_c"]
        }
    ]
)

# Wöchentlicher Bericht
resultat = rapport.generer_rapport(periode_jours=7)

# Archivierung des Berichts
with open(f"reports/competitor_{datetime.now().strftime('%Y-%m-%d')}.md",
          "w") as f:
    f.write(resultat)

Best Practices für nutzbare Berichte

  • Konsistenz: Nutzen Sie stets dieselbe Struktur, um Vergleiche zu erleichtern.
  • Priorisierung: Ordnen Sie Erkenntnisse nach geschäftlicher Relevanz, nicht nach Volumen.
  • Umsetzbarkeit: Jeder Abschnitt muss zu einer Empfehlung führen.
  • Verteilung: Passen Sie das Format an den Empfänger an (Management = Zusammenfassung, Operatives = Detail).
  • Archivierung: Bewahren Sie alle Berichte zur langfristigen Trendanalyse auf.

Kernaussagen

  • Ein automatisierter Wettbewerbsbericht deckt fünf Achsen ab: soziale Medien, Content, Launches, Wahrnehmung und Preisgestaltung.
  • Kombinieren Sie X Search und Web Search für einen vollständigen Überblick über jeden Wettbewerber.
  • Strukturieren Sie die Ergebnisse in JSON, um Ihre Dashboards zu versorgen.
  • Der Vergleich zwischen Zeiträumen offenbart strategische Änderungen.
  • Jede Erkenntnis muss zu einer umsetzbaren Empfehlung führen.
  • Archivieren Sie Ihre Berichte systematisch zur langfristigen Verfolgung.