Cap Table & Waterfall API

The tools on this site run on a set of calculation engines: build a cap table from a list of events, run an exit waterfall against a valuation, forecast a fund's economics. Those engines are also reachable directly. You send the same inputs the tool would send and get back the same computed result, so you can run the math from a script, a spreadsheet add-on, or an AI agent instead of the browser.

This is the compute API. It runs the model engines. It is not the Reporting API, which is a different surface that reads and writes your fund's data inside the Portfolio Reporting software. If you are looking to pull LP positions or post a portfolio metric, that's the one you want. This page is about running cap table and waterfall math.

The living, machine-generated reference lives at hemrock.com/developers, with the full request schemas and status codes for every endpoint. This page is the narrative version: how to get a key, how to authenticate, and how to make a call.

Which products have an API

The API runs the calculation engines: the cap table, the exit waterfall, and fund economics. Those are the tools you can call from code.

The spreadsheet models are a different thing. The Standard Financial Model, the Venture Capital Model, and the forecasting tools are Excel and Google Sheets workbooks you download and edit directly, so there is no API for them. If you want to move data in or out of one, that happens in the spreadsheet: link a forecast into the Forecast sheet (see building custom forecasts), or import and export cap table ownership through OCF.

Get a key

Keys are created under Settings → API keys. You'll see the raw token once, at creation, and never again. It looks like hk_live_…. Only a hash of it is stored, so if you lose it you generate a new one rather than recovering the old.

Treat the key like a password. It carries your account's access. If it leaks, revoke it from the same page and the next call it makes fails immediately.

Authenticate

Send the key as a bearer token on every request:

Authorization: Bearer hk_live_...  

There are no cookies and no session to manage. The v1 routes live outside the site's session wall, so a key is the only thing that identifies you. That's what makes them safe to call from a headless script or an agent.

Each call runs against your account's product entitlements. The cap table and waterfall engines need the paid Cap Table & Exit Waterfall product; a valid key without it gets a 402 with a checkoutUrl in the error details, so an agent can resolve the block and retry. Fund economics is free with any valid key.

Make a call

The base URL is https://www.hemrock.com/v1 (an api.hemrock.com alias is coming, and points at the same routes). Here's a cap table computed from a single founder issuance:

curl -X POST https://www.hemrock.com/v1/cap-table/compute \  
  -H "Authorization: Bearer hk_live_..." \  
  -H "Content-Type: application/json" \  
  -d '{  
    "events": [  
      { "type": "common_issuance", "label": "Founders",  
        "grants": [{ "id": "f", "name": "Founder", "shares": 8000000, "kind": "founder" }] }  
    ]  
  }'  

You get back the cap table snapshots after each event and the final ownership table.

The endpoints

Three compute endpoints, plus two you can hit without a key to discover what's available:

• POST /v1/cap-table/compute: takes a list of cap table events, returns the snapshots and final ownership.
• POST /v1/exit-waterfall/compute: takes a waterfall model and an exit valuation, returns who gets what.
• POST /v1/fund-economics/compute: the free fund-shape forecast.
• GET /v1/catalog: the models, their endpoints, and pricing. No key required.
• GET /v1/openapi.json: the machine-readable OpenAPI spec. No key required.

The exact request body for each, field by field, is in the OpenAPI spec and rendered on the developer reference. I keep the schemas there rather than copy them here so the two never drift apart.

Errors

Every failure comes back the same shape, with a stable code you can branch on:

{  
  "error": {  
    "code": "payment_required",  
    "message": "This API needs the Cap Table & Exit Waterfall product.",  
    "retryable": false  
  }  
}  

A missing or bad key is a 401. A valid key without the required product is a 402, and its details carry the checkoutUrl. A malformed body is a 400 that names what was wrong.

From an agent (MCP)

If you're driving this from Claude or another AI client, you don't have to write HTTP at all. The same engines are exposed as MCP tools, so the agent calls cap_table_compute and exit_waterfall_compute as native tools. Add the connector at https://mcp.hemrock.com/mcp, drop your hk_live_ key into it, and it forwards that key as the bearer token on every compute call. The discovery tools (list_models, get_access) work without a key. The full guide is at hemrock.com/mcp.

Where to go next

For what the engines are actually computing, the concept guides are the place to start: exit waterfalls walks through the allocation math, and equity and ownership covers how a cap table is structured. If you'd rather work in a spreadsheet than in code, the Cap Table & Exit Waterfall tool runs the same engines with every cell open.