Preisfinder

Was macht Preisfinder?

Teilen Sie Ihre Produkt-URL oder -Beschreibung mit. Das Tool findet 5 Wettbewerber, ruft deren tatsächliche Preisseiten ab und erstellt einen vollständigen Preisintelligenzbericht: das dominante Modell in Ihrer Nische, eine Benchmark-Preistabelle, Feature-Gate-Analyse, Positionierungskarte und eine konkrete Preisempfehlung für Ihr Produkt.

Keine API-Keys erforderlich. Läuft komplett mit kostenlosen pip-Abhängigkeiten. Optionale API-Keys verbessern die Qualität.

---

Null-Halluzinations-Richtlinie: Jeder Preis, jeder Tarifname und jedes Feature-Gate im Output muss auf dem Inhalt der abgerufenen Preisseite oder einem DuckDuckGo-Suchschnipsel basieren. Dies gilt für:

• Wettbewerbspreise: wörtlich aus dem abgerufenen Seiteninhalt extrahiert
• "Kontakt für Preisangabe": unverändert übernommen, niemals geschätzt oder durch eine Zahl ersetzt
• Tarifnamen: exakt von der Seite kopiert, nicht paraphrasiert
• Funktionslisten: aus dem Seiteninhalt extrahiert, nicht aus Produktwissen abgeleitet
• Positionierungsbeobachtungen: nur aus den Daten der Benchmark-Tabelle abgeleitet

---

Häufige Fehler

Der Agent wird versuchen, ...	Warum das falsch ist
"Kontakt für Preisangabe" durch einen geschätzten Preis zu ersetzen	Schätzen Sie niemals Enterprise-Preise. Notieren Sie es exakt als "Kontakt für Preisangabe".
Trainingswissen für Wettbewerbspreise zu verwenden	Jeder Preis muss auf abgerufenen Seiteninhalten oder einem Suchschnipsel basieren.
Den Schritt zur Wettbewerberbestätigung zu überspringen	Zeigen Sie immer die gefundenen Wettbewerber an und warten Sie auf Bestätigung. Falsche Wettbewerber = falsche Benchmarks.
Einen Preis ohne Bezug auf Benchmark-Daten zu empfehlen	Jede Preisempfehlung muss eine bestimmte Zahl aus der Benchmark-Tabelle zitieren.
Eine Seite als hochwertig zu markieren, wenn der Inhalt < 500 Zeichen beträgt	< 500 Zeichen bedeutet, dass die Seite nicht abgerufen wurde -- markieren Sie data_quality als 'low' und verwenden Sie den Suchschnipsel-Fallback.
Em-Dashes in der Ausgabe zu verwenden	Ersetzen Sie alle Em-Dashes durch Bindestriche.

---

Referenzdateien vor jedem Durchlauf lesen

cat references/pricing-models.md
cat references/extraction-guide.md
cat references/positioning-guide.md

---

Schritt 1: Setup-Prüfung

echo "TAVILY_API_KEY:    ${TAVILY_API_KEY:+gesetzt (Suchqualität verbessert)}${TAVILY_API_KEY:-nicht gesetzt, DuckDuckGo wird verwendet (kostenlos)}"
echo "FIRECRAWL_API_KEY: ${FIRECRAWL_API_KEY:+gesetzt (JS-Rendering verbessert)}${FIRECRAWL_API_KEY:-nicht gesetzt, requests+BS4 wird verwendet (kostenlos)}"
echo ""
python3 -c "from ddgs import DDGS; import requests, bs4, html2text; print('Abhängigkeiten OK')" 2>/dev/null \
  || echo "FEHLER: Fehlende Abhängigkeiten. Führen Sie aus: pip install ddgs requests beautifulsoup4 html2text"

Wenn Abhängigkeiten fehlen: Stoppen Sie sofort. Teilen Sie dem Benutzer mit: "Fehlende Python-Abhängigkeiten. Führen Sie diesen Befehl aus, um sie zu installieren: pip install ddgs requests beautifulsoup4 html2text -- alles kostenlos, keine Konten erforderlich. Versuchen Sie es dann erneut."

Wenn nur API-Keys fehlen: Fahren Sie fort. DuckDuckGo und requests+BS4 sind die kostenlosen Standardeinstellungen.

Produkt-Slug ableiten:

PRODUCT_SLUG=$(python3 -c "
from urllib.parse import urlparse
import sys, re
url = 'URL_HERE'
if url.startswith('http'):
    host = urlparse(url).netloc.replace('www.', '')
    print(host.split('.')[0])
else:
    print(re.sub(r'[^a-z0-9]', '-', url[:30].lower()).strip('-'))
")
echo "Produkt-Slug: $PRODUCT_SLUG"

---

Schritt 2: Eingabe parsen

Sammeln Sie aus der Konversation:

• product_url: Die abzurufende URL (erforderlich, es sei denn, der Benutzer fügt direkt eine Beschreibung ein)
• geography: optional -- US / Europa / Indien / global. Standard: US

Wenn der Benutzer nur eine eingefügte Beschreibung (keine URL) bereitstellt: Überspringen Sie die Schritte 3 und 4. Gehen Sie direkt zu Schritt 4 (Produktanalyse) und verwenden Sie den eingefügten Text als product_content. Setzen Sie page_source auf user_description und notieren Sie dies in data_quality_flags.

Wenn weder URL noch Beschreibung vorhanden sind: Fragen Sie: "Was ist die URL Ihres Produkts oder Startups? Oder fügen Sie eine kurze Beschreibung ein: Was es tut, für wen es ist und was es anders macht."

---

Schritt 3: Produktseite abrufen

Primär: Firecrawl (wenn FIRECRAWL_API_KEY gesetzt ist)

curl -s -X POST https://api.firecrawl.dev/v1/scrape \
  -H "Authorization: Bearer $FIRECRAWL_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"url": "URL_HERE", "formats": ["markdown"], "onlyMainContent": true}' \
  | python3 -c "
import sys, json
d = json.load(sys.stdin)
content = d.get('data', {}).get('markdown', '') or d.get('markdown', '')
print(f'Über Firecrawl abgerufen: {len(content)} Zeichen')
open('/tmp/pf-product-raw.md', 'w').write(content)
"

Fallback: requests + BS4 (kostenlos, immer verfügbar)

python3 << 'PYEOF'
import requests, html2text, random

USER_AGENTS = [
    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
]
headers = {"User-Agent": random.choice(USER_AGENTS), "Accept": "text/html,application/xhtml+xml;q=0.9,*/*;q=0.8"}
resp = requests.get("URL_HERE", headers=headers, timeout=20, allow_redirects=True)
converter = html2text.HTML2Text()
converter.ignore_images = True
converter.body_width = 0
content = converter.handle(resp.text)[:8000]
print(f'Über requests+BS4 abgerufen: {len(content)} Zeichen')
open('/tmp/pf-product-raw.md', 'w').write(content)
PYEOF

Kontrollpunkt:

python3 -c "
content = open('/tmp/pf-product-raw.md').read()
if len(content) < 200:
    print('FEHLER: Weniger als 200 Zeichen abgerufen -- die Seite verwendet möglicherweise JS-Rendering')
else:
    print(f'Inhalt OK: {len(content)} Zeichen')
"

Wenn Inhalt < 200 Zeichen: Teilen Sie dem Benutzer mit: "Die Produktseite hat zu wenig Inhalt zurückgegeben -- die Site verwendet möglicherweise JavaScript-Rendering. Bitte fügen Sie eine kurze Beschreibung ein: Was Ihr Produkt tut, für wen es ist und was es von Wettbewerbern unterscheidet."

---

Schritt 4: Produktanalyse (KI)

Seiteninhalt ausgeben:

python3 -c "
content = open('/tmp/pf-product-raw.md').read()[:5000]
print('=== PRODUKTSEITE (erste 5000 Zeichen) ===')
print(content)
"

KI-Anweisungen: Analysieren Sie die obige Produktseite und extrahieren Sie:

• product_name: Der Produkt- oder Firmenname
• one_line_description: Was es tut, für wen, Kernnutzen. Unter 20 Wörtern. Keine Marketingsprache.
• industry_taxonomy: l1 (Oberkategorie: entwicklertools / fintech / healthtech / consumer / etc.), l2 (Bereich: devops / payments / hr / etc.), l3 (spezifische Nische: CI/CD-automatisierung / embedded-payments / async-video / etc.)
• differentiators: Exakt 2-3 spezifische Dinge, die dieses Produkt auszeichnen. Diese fließen in die Empfehlung ein -- seien Sie spezifisch. Allgemeine Antworten wie "einfach zu bedienen" sind nicht akzeptabel.
• icp: buyer_persona (Berufsbezeichnung), company_type, company_size
• geography_bias: US / Europa / Indien / global
• page_source: "live_page" oder "user_description"

Schreiben Sie nach /tmp/pf-product-analysis.json:

python3 << 'PYEOF'
import json

analysis = {
    # FÜLLEN aus Ihrer obigen Analyse
    "product_name": "",
    "one_line_description": "",
    "industry_taxonomy": {"l1": "", "l2": "", "l3": ""},
    "differentiators": [],
    "icp": {"buyer_persona": "", "company_type": "", "company_size": ""},
    "geography_bias": "US",
    "page_source": "live_page"
}

json.dump(analysis, open('/tmp/pf-product-analysis.json', 'w'), indent=2)
print('Produktanalyse geschrieben.')
PYEOF

Überprüfen:

python3 -c "
import json
a = json.load(open('/tmp/pf-product-analysis.json'))
print('Produkt:', a['product_name'])
print('Branche:', a['industry_taxonomy']['l1'], '>', a['industry_taxonomy']['l2'], '>', a['industry_taxonomy']['l3'])
print('Unterscheidungsmerkmale:')
for d in a['differentiators']:
    print(f'  - {d}')
"

---

Schritt 4b: Phase 1 -- Wettbewerber finden

ls scripts/research.py 2>/dev/null && echo "Skript gefunden" || echo "FEHLER: scripts/research.py nicht gefunden -- kann nicht fortfahren"

python3 scripts/research.py \
  --phase discover \
  --product-analysis /tmp/pf-product-analysis.json \
  --output /tmp/pf-competitors-raw.json

Ergebnisse zur KI-Überprüfung ausgeben:

python3 -c "
import json
data = json.load(open('/tmp/pf-competitors-raw.json'))
print(f'Durchgeführte Suchen: {len(data[\"competitor_searches\"])}')
for s in data['competitor_searches']:
    print(f'\nAbfrage: {s[\"query\"]}')
    for r in s.get('results', [])[:6]:
        print(f'  - {r[\"title\"]} | {r[\"url\"]}')
        print(f'    {r.get(\"snippet\",\"\")[:150]}')
"

KI-Anweisungen: Lesen Sie die obigen Suchergebnisse. Wählen Sie genau 5 Wettbewerber-Unternehmen aus, die:

1. In den Suchtiteln oder -schnipseln genannt werden
2. In derselben L3-Nische wie das zu analysierende Produkt sind
3. Tatsächliche Softwareprodukte sind (keine Agenturen, List-Artikel oder Bewertungsseiten)
4. Sich voneinander unterscheiden

Schreiben Sie für jeden Wettbewerber: name, url, pricing_url (Preisseite -- falls nicht in den Schnipseln gefunden, als [url]/pricing ableiten), description (ein Satz aus dem Schnipsel), source_url.

---

Schritt 5: Wettbewerberbestätigung

python3 << 'PYEOF'
import json

analysis = json.load(open('/tmp/pf-product-analysis.json'))

# FÜLLEN: 5 Wettbewerber aus den obigen Suchergebnissen
candidates = [
    # {"name": str, "url": str, "pricing_url": str, "description": str, "source_url": str}
]

print(f"\nGefundene 5 Wettbewerber für {analysis['product_name']} in {analysis['industry_taxonomy']['l3']}:\n")
for i, c in enumerate(candidates, 1):
    print(f"  {i}. {c['name']} -- {c['description']}")
    print(f"     Produkt: {c['url']}")
    print(f"     Preise: {c['pricing_url']}")

data = json.load(open('/tmp/pf-competitors-raw.json'))
data['competitor_candidates'] = candidates
json.dump(data, open('/tmp/pf-competitors-raw.json', 'w'), indent=2)
PYEOF

Teilen Sie dem Benutzer mit: "Dies sind die 5 Wettbewerber, von denen ich Preisdaten abrufen werde. Fügen Sie welche hinzu, entfernen Sie welche oder tauschen Sie sie aus -- oder sagen Sie 'sieht gut aus', um fortzufahren."

Auf Bestätigung warten. Wenn der Benutzer die Liste bearbeitet, aktualisieren Sie die Kandidaten entsprechend. Schreiben Sie dann die bestätigte Liste:

python3 << 'PYEOF'
import json

# FÜLLEN: bestätigte Wettbewerberliste (nach Benutzerüberprüfung)
confirmed = [
    # {"name": str, "url": str, "pricing_url": str}
]

json.dump({"confirmed_competitors": confirmed}, open('/tmp/pf-competitors-confirmed.json', 'w'), indent=2)
print(f"Bestätigte {len(confirmed)} Wettbewerber für die Preisrecherche.")
for c in confirmed:
    print(f"  - {c['name']} | Preise: {c['pricing_url']}")
PYEOF

---

Schritt 6: Phase 2 -- Preisseiten abrufen

python3 scripts/research.py \
  --phase fetch-pricing \
  --competitors /tmp/pf-competitors-confirmed.json \
  --output /tmp/pf-pricing-raw.json

Dies ruft die Preisseite jedes Wettbewerbers mit einem 3-stufigen Fallback ab:

1. Direkter Abruf: requests + beautifulsoup4 + html2text
2. Google-Cache: webcache.googleusercontent.com/search?q=cache:[url]
3. DuckDuckGo-Suche: "[Wettbewerber]" preise tarife kosten pro monat (Schnipsel-Fallback)

Abrufzusammenfassung ausgeben:

python3 -c "
import json
data = json.load(open('/tmp/pf-pricing-raw.json'))
print(f'Abgerufene Wettbewerber: {data[\"competitors_fetched\"]}')
print()
for r in data['results']:
    quality_label = {'high': 'GUT', 'medium': 'OK', 'low': 'NUR SCHNIPSEL'}.get(r['data_quality'], r['data_quality'])
    print(f'  {r[\"name\"]:20} {r[\"source\"]:15} {r[\"content_length\"]:5} Zeichen  [{quality_label}]')
"

Wenn ein Wettbewerber data_quality: low hat: Dies bedeutet, dass die Preisseite blockiert oder JS-gerendert wurde. Die Analyse wird mit den Suchschnipseln fortgesetzt, aber das Vertrauen für diesen Wettbewerber wird als niedrig vermerkt.

---

Schritt 7: Preisextraktion (KI)

Alle rohen Preisinhalte ausgeben:

python3 -c "
import json
data = json.load(open('/tmp/pf-pricing-raw.json'))
for r in data['results']:
    print(f'\n=== {r[\"name\"]} (Quelle: {r[\"source\"]}, Qualität: {r[\"data_quality\"]}) ===')
    print(f'Preis-URL: {r[\"pricing_url\"]}')
    print(r['content'][:4000])
    print('---')
"

KI-Anweisungen: Extrahieren Sie für jeden Wettbewerber strukturierte Preisdaten aus dem obigen Inhalt. Befolgen Sie references/extraction-guide.md zur Identifizierung von Tarifen, Preisen, Limits und CTAs.

Null-Halluzinations-Regeln:

1. Preise nur wörtlich aus dem Inhalt extrahieren. Wenn ein Preis nicht im Inhalt ist, schreiben Sie null.
2. "Kontakt für Preisangabe" exakt so notieren. Niemals durch eine geschätzte Zahl ersetzen.
3. data_quality: low bedeutet, dass die Daten aus Suchschnipseln stammen - extrahieren Sie, was da ist, aber füllen Sie keine Lücken mit Trainingswissen.
4. Für jedes nicht im Inhalt vorhandene Feld: schreiben Sie "nicht in den Seitendaten gefunden".
5. Jährliche Preise: immer den monatlichen Äquivalentwert zusammen mit der Jahressumme notieren.

Schreiben Sie nach /tmp/pf-pricing-extracted.json:

python3 << 'PYEOF'
import json

# FÜLLEN: ein Objekt pro Wettbewerber, folgt dem Schema unten
extracted = [
    # {
    #   "competitor": str,
    #   "pricing_url": str,
    #   "data_quality": "high" | "medium" | "low",
    #   "pricing_model": "per-seat" | "flat-rate" | "usage-based" | "freemium" | "tiered-flat" | "hybrid",
    #   "billing_cadence": ["monatlich"] | ["jährlich"] | ["monatlich", "jährlich"],
    #   "annual_discount": str,           # z.B. "20%" oder "nicht in den Seitendaten gefunden"
    #   "free_tier": true | false,
    #   "free_trial": true | false,
    #   "free_trial_days": int | null,
    #   "tiers": [
    #     {
    #       "name": str,
    #       "price_monthly": float | null,       # null bei "Kontakt für Preisangabe"
    #       "price_annual_monthly": float | null, # monatlicher Äquivalentwert bei jährlicher Abrechnung
    #       "price_note": str,                   # "Kontakt für Preisangabe", "Kostenlos" oder leer
    #       "seats": str,                        # "pro Sitzplatz", "unbegrenzt", "bis zu 5", etc.
    #       "key_limits": [str],                 # Speicher, API-Aufrufe, Projekte, etc.
    #       "key_features": [str]                # Top 3-5 Funktionen in diesem Tarif
    #     }
    #   ],
    #   "enterprise_tier": true | false,
    #   "enterprise_pricing": str,               # "Kontakt für Preisangabe" oder tatsächlicher Preis
    #   "regional_pricing": str | null           # z.B. "Indien: ₹999/Monat" oder null
    # }
]

json.dump(extracted, open('/tmp/pf-pricing-extracted.json', 'w'), indent=2, ensure_ascii=False)
print(f'{len(extracted)} Wettbewerber extrahiert.')
PYEOF

Überprüfen:

python3 -c "
import json
data = json.load(open('/tmp/pf-pricing-extracted.json'))
for c in data:
    tiers = [t['name'] for t in c['tiers']]
    print(f\"  {c['competitor']:20} | Modell: {c['pricing_model']:15} | Tarife: {', '.join(tiers)}\")
"

Wichtig: Wenn das Tool sich weigert, einen Preis für einen bestimmten Tarif zu extrahieren, überprüfen Sie den Inhalt in Schritt 7 noch einmal. Jeder Preis muss sich auf eine Zahl im abgerufenen Inhalt zurückführen lassen.

---

Schritt 8: Benchmark-Analyse (KI)

Lesen Sie die Referenz: references/pricing-models.md

cat references/pricing-models.md

KI-Anweisungen: Identifizieren Sie aus den extrahierten Daten der Wettbewerber das dominante Preismodell:

• Wenn die Mehrheit der Wettbewerber pro Sitzplatz abrechnet: Modell = per-seat
• Wenn die Mehrheit Flatrate-Tarife hat: Modell = flat-rate
• Wenn die Mehrheit verbrauchsbasierte Preise hat: Modell = usage-based
• Wenn 2+ Modelle üblich sind: Modell = hybrid

Erstellen Sie eine Vergleichstabelle mit dem niedrigsten, höchsten und medianen Monatspreis für jeden Tariftyp.

Schreiben Sie nach /tmp/pf-benchmark-analysis.json:

python3 << 'PYEOF'
import json

benchmark = {
    "dominant_pricing_model": "",  # eines aus: per-seat / flat-rate / usage-based / freemium / tiered-flat / hybrid
    "model_confidence": "",       # "high" / "medium" / "low"
    "model_rationale": "",        # 2-3 Sätze, die erklären, warum dieses Modell als dominant identifiziert wurde
    "benchmark_table": [
        # {
        #   "tier": "Entry-Level",     # kann "Free", "Starter", "Basic", "Professional", "Enterprise" oder ein anderer Name sein
        #   "price_min": 0.0,
        #   "price_max": 99.0,
        #   "price_median": 29.0,
        #   "num_competitors_with_tier": 4,
        #   "typical_features": [str],
        #   "typical_limits": [str]
        # }
    ],
    "feature_gates": {
        "common_free_features": [str],
        "paid_gates": [str],          # Funktionen, die häufig in kostenpflichtigen Tarifen gesperrt sind
        "premium_gates": [str]       # Funktionen, die nur in den höchsten Tarifen verfügbar sind
    },
    "annual_discount_benchmark": "", # z.B. "Typischerweise 20% Rabatt bei jährlicher Abrechnung"
    "enterprise_pricing_pattern": "" # z.B. "Alle Wettbewerber nutzen 'Kontakt für Preisangabe' für Enterprise"
}

json.dump(benchmark, open('/tmp/pf-benchmark-analysis.json', 'w'), indent=2)
PYEOF

---

Schritt 9: Positionierungsbericht und Empfehlung (KI)

Referenz lesen: references/positioning-guide.md

cat references/positioning-guide.md

KI-Anweisungen: Basierend auf der Produktanalyse und der Benchmark-Tabelle:

1. Wettbewerbspositionierungskarte: Zeichnen Sie eine 2x2-Matrix (Preis vs. Funktionsumfang) unter Verwendung der Benchmark-Daten. Positionieren Sie das Produkt relativ zu den Wettbewerbern.

2. Bereich für Preisextraktion:

   • Empfohlener Preisbereich unter Bezugnahme auf die Benchmark-Tabelle
   • Begründen Sie dies mit spezifischen Zahlen aus pf-pricing-extracted.json

3. Tarifstruktur-Empfehlung:

   • Wie viele Tarife? (typischerweise 3-4)
   • Welche Funktionen in jedem Tarif? (basierend auf Feature-Gate-Analyse)
   • Preisstrategie: penetration / skimming / value-based / competitive-matching / freemium

4. Strategie-Hinweise:

   • Risiken des empfohlenen Ansatzes
   • Was das dominante Preismodell für die Preisstrategie bedeutet
   • Ob regionalisierte Preise sinnvoll sind (basierend auf geography_bias und regionalen Preisdaten)

Schreiben Sie den endgültigen Bericht:

python3 << 'PYEOF'
import json

# Alle zuvor geschriebenen Dateien laden
product = json.load(open('/tmp/pf-product-analysis.json'))
extracted = json.load(open('/tmp/pf-pricing-extracted.json'))
benchmark = json.load(open('/tmp/pf-benchmark-analysis.json'))

# Erstellen Sie den Preisintelligenzbericht als Dict für die Ausgabe
report = {
    "product": product['product_name'],
    "report_type": "pricing_intelligence",
    "executive_summary": {
        "dominant_pricing_model_in_space": benchmark['dominant_pricing_model'],
        "our_recommended_strategy": "",   # 1 Satz: die empfohlene Preisstrategie
        "recommended_price_range": ""      # z.B. "19€ - 79€/Monat basierend auf Median-Preisen"
    },
    "competitive_positioning_map": {
        "axes": {"x": "Preis (niedrig -> hoch)", "y": "Funktionsumfang (grundlegend -> umfassend)"},
        "products": [
            # FÜLLEN: Position jedes Wettbewerbers + Ihr Produkt
            # {"name": str, "position": {"price": int|float, "features": int|float}, "note": str}
        ],
        "insights": [str]  # 2-3 Schlüsselerkenntnisse aus der Karte
    },
    "pricing_recommendation": {
        "rationale": "",  # Absatz: Warum diese Preisstrategie für dieses Produkt in dieser Nische geeignet ist
        "recommended_tiers": [
            # {
            #   "name": str,
            #   "target_price": float,
            #   "price_rationale": str,  # Zitieren Sie einen bestimmten Wettbewerbspreis als Referenz
            #   "must_have_features": [str],
            #   "nice_to_have_features": [str],
            #   "positioning_note": str
            # }
        ],
        "go_to_market_pricing_notes": [str],  # 2-4 umsetzbare Notizen
        "risks": [str]  # 1-2 Risiken dieses Ansatzes
    },
    "limitations_and_footnotes": {
        "data_quality_notes": [],  # Alle Low-Qualität-Preisdaten notieren
        "methodology": "Alle Preise wurden von öffentlich zugänglichen Preisseiten extrahiert. 'Kontakt für Preisangabe' ist nicht enthalten. Die Preise können sich ändern."
    }
}

# Vollständigen Bericht ausgeben
print(json.dumps(report, indent=2, ensure_ascii=False))
print()
print("---")
print(f"Bericht für {product['product_name']} abgeschlossen.")
print("Speichern Sie diesen Bericht, um ihn dem Benutzer zu präsentieren.")
PYEOF

---

Schritt 10: Bericht präsentieren

Präsentieren Sie dem Benutzer den Bericht aus Schritt 9. Sie können die wichtigsten Erkenntnisse zusammenfassen:

• Dominantes Preismodell: [Modell aus der Benchmark-Analyse]
• Empfohlene Preisstrategie: [Strategie]
• Preisspanne: [Spanne]
• 3 wichtigste Erkenntnisse:
  1. ...
  2. ...
  3. ...
• Nächste Schritte: [umsetzbare nächste Schritte zur Validierung der Preisstrategie]

Wichtig: Alle empfohlenen Preise müssen mit einer Fußnote versehen sein, die auf einen bestimmten Wettbewerber und Tarif verweist. Zum Beispiel: "Empfohlener Einstiegspreis: 29€/Monat (basierend auf dem Median der Starter-Tarife der Wettbewerber)."