openvaluation

Startup-Bewertungsmethoden als überprüfbarer Code. Berkus, Scorecard, Risk Factor Summation, die VC-Methode, First Chicago und Marktmultiplikatoren – implementiert, getestet und in der Lage, ihre Berechnung offenzulegen.

Kostenlos und Open Source, MIT-lizenziert. Reines Python, keine Abhängigkeiten, keine API-Schlüssel, keine Netzwerkaufrufe.

pip install openvaluation

Die Pre-Revenue-Methoden, die Angel-Gruppen tatsächlich nutzen, leben in Lehrbüchern, Arbeitsblättern und Tabellenkalkulationen, aber nicht in gepflegter Software. Sucht man auf GitHub nach „Berkus-Methode“, findet man eine Handvoll Skripte ohne Sterne; jedes kommerzielle Tool, das diese Methoden implementiert, hält die Arithmetik geschlossen. Dieses Paket ist das fehlende Puzzleteil: eine Bibliothek, die ein Agent, ein Skript oder ein Notebook aufrufen kann und eine vertretbare Zahl zurückbekommt, mit der Herleitung im Anhang.

from openvaluation import Engine

company = {
    "company": {"sector": "saas", "stage": "seed", "region": "us"},
    "financials": {"revenue": {"arr": 480_000}},
    "berkus": {"sound_idea": 1.0, "prototype": 1.0, "management_team": 0.8,
               "strategic_relationships": 0.4, "product_rollout": 0.6},
    "scorecard": {"management_team": 1.25, "opportunity_size": 1.4},
}

print(Engine().run_all(company, stage="seed").summary())

4 methods ran; median 4,420,000 USD (range 1,400,000–6,462,500)

  berkus                         1,900,000  [1,400,000 – 2,400,000]
  ev_arr                         3,840,000  [2,400,000 – 5,760,000]
  risk_factor_summation          5,000,000  [4,750,000 – 5,250,000]
  scorecard                      5,875,000  [5,287,500 – 6,462,500]

  2 methods could not run:
    vc_method: vc_method needs exit.value, exit.revenue (supply an exit value, or
      projected revenue at exit to apply a multiple to)
    first_chicago: first_chicago needs scenarios.success.probability, ...

Extraktion ist probabilistisch; Arithmetik sollte es nicht sein

Sprachmodelle werden ständig gefragt, was ein Startup wert ist, und sie sind darin schlecht – nicht beim Denken, sondern bei der Arithmetik und beim Erinnern, welche Methode welche Eingabe benötigt. Sie sind jedoch sehr gut darin, einen Pitch-Deck zu lesen und strukturierte Fakten herauszuziehen.

Dieses Paket zieht die Grenze zwischen diesen beiden Aufgaben. Das Modell liest die Dokumente und füllt die Felder aus. Die Engine erledigt die Arithmetik deterministisch und berichtet genau, wie sie dorthin gelangt ist. Gleiche Eingabe, gleiche Ausgabe, jedes Mal – ohne Modell in der Schleife, das abweichen könnte.

result = Engine().run(company, "berkus")
print(result.explain())

berkus: 1,900,000 USD (range 1,400,000–2,400,000)

Steps
  1. Sound idea — basic value, product risk: 500,000  — rating 1.00
  2. Prototype — technology risk: 500,000  — rating 1.00
  3. Quality management team — execution risk: 400,000  — rating 0.80
  4. Strategic relationships — market risk: 200,000  — rating 0.40
  5. Product rollout or sales — production risk: 300,000  — rating 0.60
  6. Pre-money valuation: 1,900,000  — sum of five elements

Assumptions
  cap_per_element: 500000.0

Limitations
  - Berkus caps pre-revenue value and ignores market size, growth and financials.
  - Ratings are judgements, not measurements; this run capped at 2,500,000.
  - This company reports revenue; Berkus was designed for pre-revenue companies
    and a revenue-based method will usually say more.

Sources
  - Dave Berkus, 'The Berkus Method: Valuing an Early Stage Investment' (berkonomics.com)

Jedes Ergebnis trägt seine Schritte, seine Annahmen, seine Einschränkungen und eine Quellenangabe für die Methode. Eine Bewertung, die niemand überprüfen kann, ist es nicht wert, verteidigt zu werden.

Was kann ich überhaupt ausführen?

Normalerweise kommt die Frage vor der Bewertung: Angesichts dessen, was über dieses Unternehmen bekannt ist, welche Methoden sind verfügbar, und welche fehlende Tatsache würde am meisten freischalten?

report = Engine().readiness(company)

[m.method for m in report.ready]     # ['berkus', 'scorecard', 'risk_factor_summation', 'ev_arr']
report.unlocks()
# {'exit.value|exit.revenue': ('vc_method',),
#  'financials.ebitda': ('ev_ebitda',),
#  'financials.revenue.annual': ('ev_revenue',)}

unlocks() ist danach geordnet, wie viele Methoden jedes fehlende Feld freischaltet, sodass der erste Eintrag die nützlichste Sache ist, die man herausfinden kann. Ein | in einem Pfad bedeutet, dass eines der beiden Felder ausreicht.

Eine als bereit gemeldete Methode läuft immer – diese Invariante ist getestet, denn ein Bereitschaftsbericht, der lügt, ist schlimmer als keiner.

Die Methoden

Vollständige Dokumentation für jede Methode – Formel, durchgerechnetes Beispiel, Einschränkungen und Quelle, jeweils eine Seite. Jedes Beispiel auf diesen Seiten wird von der Testsuite ausgeführt, sodass nichts vom Code abweichen kann.

Jede Methode ist aus ihrer veröffentlichten Beschreibung implementiert und zitiert diese. Die Scorecard-Gewichte stammen von Bill Payne (30 % Team, 25 % Gelegenheit, 15 % Produkt, 10 % Wettbewerb, 10 % Vertrieb, 5 % Investitionsbedarf, 5 % Sonstiges); Berkus begrenzt fünf Elemente auf je 500.000; Risk Factor Summation verschiebt einen vergleichbaren Durchschnitt um 250.000 pro Schritt über zwölf Faktoren. Jede dieser Konstanten ist ein Konstruktorargument, keine magische Zahl, die in der Arithmetik versteckt ist.

from openvaluation import Berkus, RiskFactorSummation

Berkus(cap_per_element=300_000)          # a market where 500k is too rich
RiskFactorSummation(step=100_000)        # finer-grained risk adjustments

Benchmark-Daten sind Ihr Problem, und das Paket sagt es

Drei Methoden benötigen externe Zahlen: was vergleichbare Unternehmen wert sind, mit welchem Multiplikator ein Sektor handelt, mit welchem Zinssatz ein Fonds unterzeichnet. Diese Zahlen werden veralten, und keine Bibliothek sollte etwas anderes behaupten, also kommen sie über einen Provider, den Sie bereitstellen.

Der Standard-Provider liefert illustrative Platzhalter – runde, undatierte Zahlen, damit Beispiele laufen. Jede Bewertung, die sie berührt, sagt dies in ihren Einschränkungen:

  - Benchmark figures are illustrative placeholders, not market data; replace
    StaticBenchmarks with a real source before relying on this figure

Methoden, die niemals Marktdaten konsultieren, wie Berkus, tragen diesen Hinweis nicht. Liefern Sie echte Zahlen, und er verschwindet:

from openvaluation import Engine, Multiple, TableBenchmarks

benchmarks = TableBenchmarks(
    seed_valuations={"saas": 4_200_000},
    multiple_table={("saas", "ARR"): Multiple(4.1, 6.8, 11.2, basis="ARR",
                                              source="Our comp set", sample_size=180,
                                              as_of="2026-06-30")},
    rate_table={"seed": 0.5},
    citations=("Our comp set, n=180, June 2026",),
)

engine = Engine(benchmarks=benchmarks)

Oder implementieren Sie BenchmarkProvider über das, was Sie haben – eine Datenbank, eine API, eine Tabellenkalkulation. Drei Methoden, alle synchron. Sektor-Multiplikatoren und Kapitalkosten, veröffentlicht von Aswath Damodaran an der NYU Stern, sind der übliche kostenlose Ausgangspunkt.

Ein Provider, der keine Zahl hat, wirft UnknownBenchmark, anstatt eine Schätzung zu ersetzen, denn eine Bewertung, die auf einem erfundenen Multiplikator basiert, ist schlimmer als keine Bewertung.

Geben Sie es einem KI-Agenten

Liefern Sie die Methoden an das Modell, mit dem Sie bereits sprechen. Der MCP-Server stellt vier Tools bereit, und da die Arithmetik in Python stattfindet, kann das Modell die Summen nicht falsch machen:

pip install "openvaluation[mcp]"

{"mcpServers": {"openvaluation": {"command": "openvaluation-mcp"}}}

Die Anweisungen des Servers sagen dem Modell die Dinge, die es sonst falsch machen würde: dass Berkus- und Scorecard-Bewertungen Urteile sind, die Belege benötigen, dass die mitgelieferten Benchmark-Zahlen Platzhalter sind, deren Einschränkung weitergegeben werden muss, und dass der Median allein nicht die Antwort ist.

Dieselben vier Funktionen sind ohne MCP importierbar, für einen HTTP-Handler oder ein Notebook:

from openvaluation.tools import check_readiness, value_company

check_readiness(company)   # plain dicts in, plain dicts out

Von der Kommandozeile

openvaluation company.json                     # every applicable method
openvaluation company.json --readiness         # what can run, what is missing
openvaluation company.json --method berkus --explain
openvaluation company.json --json              # for piping onward
openvaluation --list-methods

Eingabeformat

Ein einfaches verschachteltes Dict – was auch immer Ihr Extraktionsschritt produziert hat. Felder werden über gepunktete Pfade gelesen, sodass nichts vollständig sein muss:

{
  "company":    {"sector": "saas", "stage": "seed", "region": "us"},
  "financials": {"revenue": {"arr": 480000, "annual": 520000}, "ebitda": 90000},
  "product":    {"stage": "mvp"},
  "berkus":     {"sound_idea": 1.0, "prototype": 0.8},
  "scorecard":  {"management_team": 1.25, "opportunity_size": 1.4},
  "risk":       {"management": 2, "competition": -1},
  "exit":       {"revenue": 40000000, "years": 5, "dilution": 0.3},
  "funding":    {"round_size": 2000000},
  "scenarios":  {"success": {"value": 80000000, "probability": 0.15},
                 "base":    {"value": 15000000, "probability": 0.35},
                 "failure": {"value": 0,        "probability": 0.50}}
}

Beträge können nackte Zahlen, numerische Zeichenfolgen oder {"value": 480000, "currency": "USD"}-Objekte sein. Raten können 0.4 oder 40 sein. Null zählt als abwesend für Mengen wie Umsatz, denn null Umsatz und unbekannter Umsatz sind für diese Methoden dieselbe Eingabe.

Was dies nicht ist

• Keine Anlageberatung und keine 409A-Bewertung. Diese Methoden erzeugen Verhandlungsanker und Plausibilitätsprüfungen. Eine Bewertung mit rechtlichem oder steuerlichem Status benötigt einen qualifizierten Gutachter.

• Kein Extraktor. Es nimmt strukturierte Fakten; sie aus einem Pitch-Deck herauszuholen ist eine separate Aufgabe und eine gute für ein Sprachmodell.

• Keine Quelle für Marktdaten. Siehe oben.

• Keine Urteils-Engine. Berkus-Bewertungen und Scorecard-Faktoren sind Urteile über ein Unternehmen. Das Paket erfasst und wendet sie an; es bildet sie nicht.

Wenn Methoden um mehr als den Median abweichen, sagt der Bericht dies – denn diese Abweichung ist Information, und sie durch Mittelung zu zerstören, vernichtet sie.

Anforderungen

Python 3.9+ (entwickelt und getestet auf 3.11). Keine Laufzeitabhängigkeiten.

Woher das kommt

Ich habe die Bewertungs-Engine hinter Wakeworth gebaut, die Startups aus hochgeladenen Dokumenten bewertet. Die Methoden selbst sind öffentliches Wissen und gehören in öffentlichen Code; was dort proprietär bleibt, ist die Dokumentextraktion und die Berichterstattung darum herum. Dieses Paket ist die Methodenschicht, eigenständig aus den veröffentlichten Beschreibungen neu aufgebaut, mit offengelegten Konstanten und jedem Ergebnis, das seine Berechnung zeigt.

Mitwirken

Issues und Pull Requests sind willkommen. Ich pflege dies auf Best-Effort-Basis neben anderer Arbeit, also erwarten Sie durchdachte Antworten eher als schnelle. Die nützlichsten Beiträge sind eine Methode, die aus einer zitierbaren Quelle implementiert ist, oder ein Fall, in dem die Arithmetik hier von einem durchgerechneten Beispiel in der Literatur abweicht.

git clone https://github.com/yagebin79386/openvaluation
cd openvaluation
pip install -e ".[dev]"
pytest

Lizenz

MIT – siehe LICENSE.

Zuletzt aktualisiert: 2026-08-20 · Changelog