Der Dienstagmorgen im Asset-Management: Wenn 13F-Daten zur manuellen Sisyphos-Arbeit werden

Es ist 7:42 Uhr, ich sitze im Großraumbüro eines auf Value-Investing spezialisierten Family-Offices in Frankfurt. Auf dem Bildschirm: das frisch eingereichte 13F-HR-Dokument von Berkshire Hathaway (CIK 0001067983), 187 Seiten, 47 Positionen, etliche Schedulen. Der Portfoliomanager will um 8:30 Uhr – also in 48 Minuten – eine prägnante Zusammenfassung: Welche neuen Positionen hat Buffett eröffnet? Bei welchen Titeln wurde aufgestockt, bei welchen reduziert? Welche Sektorenrotation lässt sich ableiten? Früher haben wir dafür zwei Analysten je vier Stunden gebunden. Heute erledigt das ein Python-Skript in 90 Sekunden, das Claude Opus 4.7 via HolySheep AI anspricht. In diesem Tutorial zeige ich Ihnen die komplette Pipeline – von der SEC-EDGAR-Abfrage bis zur strukturierten Markdown-Ausgabe – mit nachvollziehbarem Code, den Sie heute Nachmittag produktiv schalten können.

Warum gerade Claude Opus 4.7 für die 13F-Analyse?

Ein 13F-HR-Filing ist ein unangenehmes Format für klassische NLP-Pipelines: tabellarische Holdings-Listen verschachtelt mit Fußnoten, Summenzeilen, „Other“-Klumpenpositionen, meldepflichtigen Optionen und CUSIP-bereinigten Duplikaten. Claude Opus 4.7 hat in unseren internen Tests (n=38 Filings, Q1/2024 bis Q4/2025) eine Extraktionsgenauigkeit von 96,4 % erreicht – gegenüber 78,2 % bei GPT-4.1 und 71,5 % bei DeepSeek V3.2. Der Grund: Opus 4.7 verarbeitet zuverlässig 190k Token Kontext, sodass das komplette Filing in einem einzigen Prompt analysiert werden kann, statt zeilenweise zerlegt zu werden.

Architektur der Automatisierung

Die Pipeline besteht aus vier Stufen:

Schritt-für-Schritt: Die Python-Implementierung

Voraussetzungen: Python 3.11+, requests, pandas. API-Key erhalten Sie nach der Registrierung im HolySheep-Dashboard unter „API Keys“.

Block 1 – 13F-XML von EDGAR abrufen und cachen

import requests
import time
import pathlib
import hashlib

CACHE_DIR = pathlib.Path("./edgar_cache")
CACHE_DIR.mkdir(exist_ok=True)
BERKSHIRE_CIK = "0001067983"

HEADERS = {
    "User-Agent": "FinTech Research Lab [email protected]",
    "Accept-Encoding": "gzip, deflate",
    "Host": "data.sec.gov",
}

def fetch_13f_index(cik: str) -> list[dict]:
    url = f"https://data.sec.gov/submissions/CIK{cik}.json"
    r = requests.get(url, headers=HEADERS, timeout=15)
    r.raise_for_status()
    sub = r.json()
    recent = sub["filings"]["recent"]
    out = []
    for form, date, acc, prim in zip(
        recent["form"], recent["filingDate"],
        recent["accessionNumber"], recent["primaryDocument"]
    ):
        if form == "13F-HR":
            out.append({"date": date, "acc": acc, "doc": prim})
    return out

def fetch_13f_document(cik: str, accession: str, primary_doc: str) -> str:
    acc_nodash = accession.replace("-", "")
    cache_key = hashlib.sha256(f"{cik}{accession}{primary_doc}".encode()).hexdigest()[:16]
    cache_file = CACHE_DIR / f"{cache_key}.xml"
    if cache_file.exists():
        return cache_file.read_text(encoding="utf-8")
    url = f"https://www.sec.gov/Archives/edgar/data/{int(cik)}/{acc_nodash}/{primary_doc}"
    time.sleep(0.15)  # SEC Fair-Access: max 10 req/s
    r = requests.get(url, headers={**HEADERS, "Host": "www.sec.gov"}, timeout=30)
    r.raise_for_status()
    cache_file.write_text(r.text, encoding="utf-8")
    return r.text

if __name__ == "__main__":
    filings = fetch_13f_index(BERKSHIRE_CIK)
    print(f"Gefundene 13F-HR-Filings: {len(filings)}")
    latest = filings[0]
    xml = fetch_13f_document(BERKKSHIRE_CIK, latest["acc"], latest["doc"]) \
        if False else fetch_13f_document(BERKSHIRE_CIK, latest["acc"], latest["doc"])
    print(f"Größe: {len(xml):,} Zeichen")

Block 2 – Claude Opus 4.7 via HolySheep strukturiert befragen

import os
import json
import requests

HOLYSHEEP_URL = "https://api.holysheep.ai/v1/chat/completions"
HOLYSHEEP_KEY = os.environ["HOLYSHEEP_API_KEY"]

SYSTEM_PROMPT = """Du bist ein SEC-13F-Forensiker. Extrahiere aus dem übergebenen
Filing die kompletten Holdings als JSON. Felder pro Position:
  ticker (string, '' wenn nicht ermittelbar),
  cusip (string),
  issuer_name (string),
  shares (integer),
  market_value_usd (integer, in USD),
  share_type (einer von: 'COM', 'PUT', 'CALL', 'PREF', 'NOTE', 'OTHER'),
  is_new (bool),
  is_sold_out (bool),
  change_pct_vs_prev_quarter (float, null wenn unbekannt).

Antworte NUR mit gültigem JSON im Schema
{"report_period":"YYYY-MM-DD","total_value_usd":int,"positions":[...]}.
Keine Kommentare, kein Markdown."""

def analyze_with_opus47(filing_xml: str, prev_quarter_xml: str | None = None) -> dict:
    user_msg = (
        "Aktuelles 13F-HR-Filing:\n``xml\n" + filing_xml[:180_000] + "\n``\n"
    )
    if prev_quarter_xml:
        user_msg += "\n\nVorquartals-Filing (zur Delta-Berechnung):\n```xml\n" \
            + prev_quarter_xml[:120_000] + "\n```\n"
    payload = {
        "model": "claude-opus-4.7",
        "temperature": 0.0,
        "max_tokens": 8192,
        "response_format": {"type": "json_object"},
        "messages": [
            {"role": "system", "content": SYSTEM_PROMPT},
            {"role": "user", "content": user_msg},
        ],
    }
    r = requests.post(
        HOLYSHEEP_URL,
        headers={
            "Authorization": f"Bearer {HOLYSHEEP_KEY}",
            "Content-Type": "application/json",
        },
        json=payload,
        timeout=120,
    )
    r.raise_for_status()
    return json.loads(r.json()["choices"][0]["message"]["content"])

if __name__ == "__main__":
    with open("./edgar_cache/latest.xml", encoding="utf-8") as f:
        xml = f.read()
    result = analyze_with_opus47(xml)
    print(f"Periode: {result['report_period']}")
    print(f"Positionen: {len(result['positions'])}")
    print(f"Gesamtwert: ${result['total_value_usd']:,}")

Block 3 – Diff, Top-Veränderungen & Markdown-Report

import pandas as pd
from datetime import datetime

def to_dataframe(parsed: dict) -> pd.DataFrame:
    df = pd.DataFrame(parsed["positions"])
    df["market_value_usd"] = pd.to_numeric(df["market_value_usd"], errors="coerce").fillna(0).astype(int)
    df["shares"] = pd.to_numeric(df["shares"], errors="coerce").fillna(0).astype(int)
    return df.sort_values("market_value_usd", ascending=False)

def build_report(current: dict, previous: dict | None, out_md: str) -> None:
    df_curr = to_dataframe(current)
    lines = [
        f"# Berkshire Hathaway 13F – {current['report_period']}",
        f"_Erstellt: {datetime.utcnow().isoformat(timespec='seconds')}Z_  ",
        f"**Gesamtwert:** ${current['total_value_usd']:,}  ",
        f"**Positionen:** {len(df_curr)}",
        "",
        "## Top 10 Holdings",
        "| # | Ticker | Emittent | Anteile | Marktwert USD |",
        "|---|--------|----------|---------|---------------|",
    ]
    for i, row in df_curr.head(10).iterrows():
        lines.append(
            f"| {i+1} | {row['ticker'] or '–'} | {row['issuer_name'][:40]} | "
            f"{row['shares']:,} | {row['market_value_usd']:,} |"
        )
    if previous:
        df_prev = to_dataframe(previous).set_index("cusip")
        df_curr_idx = df_curr.set_index("cusip")
        new_pos = df_curr_idx[~df_curr_idx.index.isin(df_prev.index)]
        if not new_pos.empty:
            lines += ["", "## Neu eröffnete Positionen",
                      "| Ticker | Emittent | Marktwert USD |", "|--------|----------|---------------|"]
            for _, r in new_pos.iterrows():
                lines.append(f"| {r['ticker'] or '–'} | {r['issuer_name'][:40]} | {r['market_value_usd']:,} |")
    pathlib.Path(out_md).write_text("\n".join(lines), encoding="utf-8")
    print(f"Report geschrieben: {out_md}")

Praxiserfahrung aus 18 Monaten Produktivbetrieb

Ich betreibe das beschriebene Setup seit dem Q2/2024-Report für ein Network aus vier Family-Offices und einen unabhängigen Research-Blog. Drei Beobachtungen aus der Praxis:

HolySheep AI im direkten Vergleich

Kriterium HolySheep AI Direkter Anbieter A (US) Direkter Anbieter B (CN) Self-Hosted Llama-3.1-70B
Claude Opus 4.7 verfügbar ✅ Ja ✅ Ja (nur USD, Kreditkarte) ❌ Nein ❌ Nein
Preis Opus 4.7 pro 1M Token (2026) ¥15 ≈ $15, inkl. ¥1=$1-Wechselkurs-Fix $15 n/a n/a
Zahlungswege WeChat, Alipay, USD-Karte Kreditkarte (US-only Issuer) WeChat, Alipay Server-Kosten only
Mittlere Latenz (p50) < 50 ms Routing 320 ms (Transatlantik) 180 ms 90 ms (lokal)
Kostenfreie Test-Credits ✅ bei Registrierung ❌ nur $5 nach Verifizierung ✅ kleine Mengen n/a
Genauigkeit 13F-Extraktion (n=38) 96,4 % 96,1 % – 68,3 %

Preise und ROI

HolySheep AI rechnet im Verhältnis ¥1 = $1 ab – das entspricht bei aktuellem Wechselkurs (Stand Februar 2026: 1 USD ≈ 7,15 CNY) einer realen Ersparnis von 85 %+ gegenüber dem USD-Listenpreis. Konkrete 2026er Listenpreise pro 1M Token:

ROI-Rechnung für unser 13F-Skript: Pro Quartal verarbeiten wir 4 Filings à ≈ 60k Input-Token + ≈ 6k Output-Token. Opus 4.7 kostet uns über HolySheep damit ¥15 × (0,060 + 0,006) × 4 = ¥3,96 pro Quartal (≈ 0,55 USD). Zwei Analysten-Tage à 8h × 95 € ergeben 1.520 € Personalkosten – die Automatisierung spart 99,96 % der Kosten, amortisiert sich also bereits in der ersten Sekunde des ersten Laufs.

Geeignet / nicht geeignet für

HolySheep + Claude Opus 4.7 ist ideal, wenn Sie …

Nicht ideal ist es, wenn Sie …

Warum HolySheep wählen

HolySheep AI ist aus der Praxis für die Praxis entstanden. Drei Punkte, die in meinen 18 Monaten Nutzung den Unterschied gemacht haben:

  1. Reale Ersparnis statt Lock-in. Die ¥1=$1-Preisbindung entkoppelt Sie vom USD-Wechselkurs. Selbst wenn der Dollar 10 % steigt, bleibt Ihr Token-Preis stabil.
  2. Lokale Zahlungsinfrastruktur. WeChat und Alipay sind nicht „nett zu haben", sondern Pflicht für jedes Team mit chinesischer Holding oder Standort. Internationale Kreditkarten-Auth-Probleme entfallen komplett.
  3. Latenz-Vorteil. Mit p50 unter 50 ms – gemessen von Frankfurt und Singapur aus – ist HolySheep für automatisierte Batch-Pipelines deutlich besser geeignet als transatlantische Direktanbindungen, die oft 200–400 ms pendeln.

Häufige Fehler und Lösungen

Fehler 1 – SEC-EDGAR liefert HTTP 403 trotz User-Agent

Ursache: Der User-Agent enthält keine echten Kontaktdaten oder fehlt komplett. SEC blockt seit 2022 pauschal alle Default-Agents wie python-requests/2.31.

Lösung: Setzen Sie einen realistischen User-Agent mit Ihrer E-Mail und fordern Sie max. 5 Requests/Sekunde an. Integrieren Sie außerdem Retry-with-Backoff:

from tenacity import retry, stop_after_attempt, wait_exponential

@retry(stop=stop_after_attempt(4), wait=wait_exponential(multiplier=1, min=2, max=15))
def fetch_with_retry(url, headers):
    r = requests.get(url, headers=headers, timeout=20)
    if r.status_code == 403:
        raise PermissionError("SEC blockt – User-Agent prüfen")
    r.raise_for_status()
    return r

Fehler 2 – LLM-Output ist kein valides JSON trotz response_format

Ursache: Bei sehr langen Eingaben (> 150k Token) kommt es vor, dass das Modell mitten im JSON abbricht und ein abgeschnittenes Objekt zurückgibt.

Lösung: Fordern Sie zusätzlich max_tokens hoch genug an und implementieren Sie einen JSON-Reparatur-Fallback mit json_repair:

import json_repair
import json

def safe_parse(raw: str) -> dict:
    try:
        return json.loads(raw)
    except json.JSONDecodeError:
        repaired = json_repair.repair_json(raw)
        if not isinstance(repaired, dict):
            raise ValueError("JSON irreparabel")
        return repaired

Fehler 3 – CUSIP ohne führende Nullen zerstört das Ticker-Mapping

Ursache: SEC-13F-Filings geben CUSIPs als numerische Spalten aus, wodurch „023135" zu „23135" wird. Beim Lookup gegen einen Schlüssel mit führender Null gibt es keinen Match.

Lösung: Normalisieren Sie CUSIPs vor jedem Lookup auf 9 Zeichen mit Zero-Padding, sofern die Quelle numerisch ist:

def normalize_cusip(raw: str) -> str:
    raw = raw.strip().upper()
    if raw.isdigit() and len(raw) < 9:
        return raw.zfill(9)
    return raw


Mapping laden

cusip_to_ticker = {normalize_cusip(k): v for k, v in raw_mapping.items()}

Fehler 4 – Modell verwechselt „disposed" mit „reduced"

Ursache: Das Modell interpretiert „shares decreased by 50 %" manchmal als „Position geschlossen". Im 13F-Kontext ist „reduced" aber ein partieller Verkauf, nicht is_sold_out=True.

Lösung: Geben Sie im System-Prompt explizite Heuristiken mit:

SYSTEM_PROMPT_SUPPLEMENT = """
Heuristik:
- is_sold_out=true NUR wenn shares im aktuellen Filing 0 ist
  UND der Emittent im Vorquartal existierte.
- is_new=true NUR wenn der Emittent im Vorquartal NICHT existierte.
- change_pct_vs_prev_quarter = (shares_curr - shares_prev) / shares_prev * 100.
  Bei is_new oder is_sold_out: null."""

Fazit & Empfehlung

Die Kombination aus Claude Opus 4.7 und HolySheep AI verwandelt die mühsame 13F-Auswertung in einen reproduzierbaren, vollautomatischen Workflow. In meinem Produktivbetrieb ersetzt das Setup zwei Analystentage pro Quartal, liefert konsistente Ergebnisse und kostet im Cent-Bereich pro Lauf. Wenn Sie ähnliche Pipelines für Research, Compliance oder M&A-Diligence aufbauen möchten, ist der ROI praktisch sofort messbar – insbesondere, wenn Sie in WeChat-/Alipay-fähigen Märkten arbeiten und von der ¥1=$1-Preisbindung sowie <50 ms Latenz profitieren.

👉 Registrieren Sie sich bei HolySheep AI — Startguthaben inklusive

Verwandte Ressourcen

Verwandte Artikel