openvaluation

Métodos de valoración de startups como código auditable. Berkus, Scorecard, Risk Factor Summation, el método VC, First Chicago y múltiplos de mercado — implementados, probados y capaces de mostrar su razonamiento.

Gratuito y de código abierto, con licencia MIT. Python puro, sin dependencias, sin claves de API, sin llamadas de red.

pip install openvaluation

Los métodos pre-ingresos que los grupos de ángeles realmente usan viven en libros de texto, hojas de cálculo y plantillas, pero no en software mantenido. Busca "Berkus method" en GitHub y encuentras un puñado de scripts con cero estrellas; toda herramienta comercial que implementa estos métodos mantiene la aritmética cerrada. Este paquete es esa pieza que falta: una biblioteca que un agente, un script o un notebook puede llamar y obtener un número defendible, con la derivación adjunta.

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, ...

La extracción es probabilística; la aritmética no debería serlo

A los modelos de lenguaje se les pregunta constantemente cuánto vale una startup, y son malos en ello — no en el razonamiento, sino en la aritmética y en recordar qué método necesita qué entrada. Sin embargo, son muy buenos leyendo un pitch deck y extrayendo hechos estructurados.

Este paquete traza la línea entre esas dos tareas. El modelo lee los documentos y rellena los campos. El motor hace la aritmética, de forma determinista, e informa exactamente cómo llegó al resultado. Misma entrada, misma salida, siempre — sin un modelo en el bucle que pueda desviarse.

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)

Cada resultado lleva sus pasos, sus supuestos, sus limitaciones y una cita del método. Una valoración que nadie puede verificar no merece ser defendida.

¿Qué puedo ejecutar siquiera?

Normalmente la pregunta viene antes que la valoración: dado lo que se sabe sobre esta empresa, ¿qué métodos están disponibles, y qué dato faltante desbloquearía el mayor número de ellos?

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() está ordenado por cuántos métodos libera cada campo faltante, así que la primera entrada es lo más útil que se puede ir a averiguar. Una | en una ruta significa que cualquiera de los dos campos sirve.

Un método que se reporta como listo siempre se ejecuta — ese invariante está probado, porque un informe de disponibilidad que miente es peor que ninguno.

Los métodos

Documentación completa de cada método — fórmula, ejemplo resuelto, limitaciones y fuente, una página cada uno. Cada ejemplo de esas páginas es ejecutado por la suite de pruebas, así que nada puede desviarse del código.

Cada uno está implementado a partir de su descripción publicada y la cita. Los pesos del Scorecard son los de Bill Payne (30% equipo, 25% oportunidad, 15% producto, 10% competencia, 10% ventas, 5% necesidad de inversión, 5% otros); Berkus limita cinco elementos a 500.000 cada uno; Risk Factor Summation mueve un promedio comparable en 250.000 por paso a lo largo de doce factores. Cada una de esas constantes es un argumento del constructor, no un número mágico enterrado en la aritmética.

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

Los datos de referencia son tu problema, y el paquete lo dice

Tres métodos necesitan números externos: cuánto valen las empresas comparables, con qué múltiplo cotiza un sector, a qué tasa suscribe un fondo. Esos números se quedan obsoletos y ninguna biblioteca debería fingir lo contrario, así que llegan a través de un proveedor que tú suministras.

El proveedor predeterminado incluye marcadores ilustrativos — cifras redondas y sin fecha para que los ejemplos funcionen. Cualquier valoración que los toque lo dice en sus limitaciones:

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

Los métodos que nunca consultan datos de mercado, como Berkus, no llevan esa advertencia. Suministra cifras reales y desaparece:

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)

O implementa BenchmarkProvider sobre lo que tengas — una base de datos, una API, una hoja de cálculo. Tres métodos, todos síncronos. Los múltiplos sectoriales y costes de capital publicados por Aswath Damodaran en NYU Stern son el punto de partida gratuito habitual.

Un proveedor que no tiene una cifra lanza UnknownBenchmark en lugar de sustituirla por una suposición, porque una valoración construida sobre un múltiplo inventado es peor que ninguna valoración.

Dáselo a un agente de IA

Envía los métodos al modelo con el que ya hablas. El servidor MCP expone cuatro herramientas, y como la aritmética ocurre en Python, el modelo no puede equivocarse en las sumas:

pip install "openvaluation[mcp]"

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

Las instrucciones del servidor le dicen al modelo las cosas que de otro modo haría mal: que las valoraciones de Berkus y Scorecard son juicios que necesitan evidencia, que las cifras de referencia incluidas son marcadores cuya advertencia debe transmitirse, y que la mediana por sí sola no es la respuesta.

Las mismas cuatro funciones son importables sin MCP, para un manejador HTTP o un notebook:

from openvaluation.tools import check_readiness, value_company

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

Desde la línea de comandos

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

Formato de entrada

Un dict anidado simple — lo que haya producido tu paso de extracción. Los campos se leen por ruta punteada, así que nada necesita estar completo:

{
  "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}}
}

Los importes pueden ser números simples, cadenas numéricas u objetos {"value": 480000, "currency": "USD"}. Las tasas pueden ser 0.4 o 40. El cero cuenta como ausente para cantidades como ingresos, porque ingresos cero e ingresos desconocidos son la misma entrada para estos métodos.

Lo que esto no es

• No es asesoramiento de inversión, ni una valoración 409A. Estos métodos producen anclas de negociación y comprobaciones de cordura. Una valoración con estatus legal o fiscal necesita un tasador cualificado.

• No es un extractor. Toma hechos estructurados; extraerlos de un pitch deck es una tarea aparte, y una buena para un modelo de lenguaje.

• No es una fuente de datos de mercado. Ver arriba.

• No es un motor de juicios. Las valoraciones de Berkus y los factores del Scorecard son juicios sobre una empresa. El paquete los registra y los aplica; no los forma.

Cuando los métodos discrepan en más de la mediana, el informe lo dice — porque ese desacuerdo es información, y promediarlo la destruye.

Requisitos

Python 3.9+ (desarrollado y probado en 3.11). Sin dependencias de ejecución.

De dónde viene esto

Construí el motor de valoración detrás de Wakeworth, que valora startups a partir de documentos subidos. Los métodos en sí son conocimiento público y pertenecen al código público; lo que permanece propietario allí es la extracción de documentos y los informes que los rodean. Este paquete es la capa de métodos, reconstruida de forma independiente a partir de las descripciones publicadas, con las constantes expuestas y cada resultado mostrando su razonamiento.

Contribuciones

Las issues y pull requests son bienvenidas. Mantengo esto de forma voluntaria junto a otros trabajos, así que espera respuestas meditadas más que rápidas. Las contribuciones más útiles son un método implementado a partir de una fuente citable, o un caso donde la aritmética aquí discrepe con un ejemplo resuelto en la literatura.

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

Licencia

MIT — ver LICENSE.

Última actualización: 2026-08-20 · Changelog