Automatisierte Wettbewerbsberichte
Auf dieser Seite
- Automatisierung von Wettbewerbsaufklärung
- Architektur eines vollständigen Wettbewerbsberichts
- Aufbau des Berichtssystems
- Strukturierung des Berichts in nutzbares JSON
- Vergleich von Zeiträumen zur Erkennung von Änderungen
- Planung der wiederkehrenden Ausführung
- Best Practices für nutzbare Berichte
- 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.