# Valuation API (remote · api.finance-tools.io)

Deterministic finance tools for AI agents — IRR, NPV, MOIC, DCF, WACC and sensitivity.

- Trust score: 73/100 (medium)
- Change this week: +3
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-09-27

## Components

- remote · `api.finance-tools.io`: 73/100 (this document), [markdown](https://verifymcp.io/servers/johnbehar1500-ux-valuation-api/api.md), [page](https://verifymcp.io/servers/johnbehar1500-ux-valuation-api/api)

## Channel facts

- Endpoint: `https://api.finance-tools.io/mcp`
- Transports: `streamable-http`
- Auth: `none`
- Version: `1.0.0`

## Trust breakdown

How this component scores in each security and reliability category. Every signal is checked automatically against the live server, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog)

Scored 2026-09-27.

- **Endpoint Security**: 63/100
  - The endpoint's TLS certificate is valid, in date, and uses a strong key.
  - No authorisation is required to call this server. Every tool declares its destructiveHint and none is destructive, so open access doesn't expose one.
  - HTTPS enforcement could not be verified: the plaintext port answered with HTTP 405, which proves neither a plaintext path nor enforcement.
  - HSTS check failed: the Strict-Transport-Security header is absent.
  - DNSSEC check failed: this domain isn't protected by DNSSEC.
- **Transport & Reachability**: 100/100
  - Verified streamable-http transport via a live MCP handshake.
- **Schema Quality & AI Usability**: 77/100
  - 100% of prompts and resources have a non-trivial description (not blank, and not just the item's name).
  - AI-judged instruction clarity (excellent).
  - Context-footprint check failed: tool/resource definitions use about 5664 tokens (~404/item across 14 items; 14 tools + 0 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 67/100
  - Stability check failed: schema churn in the 25 days we've observed: 1 tool removals, 0 breaking changes, 0 auth/transport breaks, 9 additions.
- **Tool Coverage**: 100/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 100% of tool parameters carry a description.
- **Tool Safety**: 100/100
  - No prompt-injection markers were found in the server instructions, tool names or descriptions we captured.
  - We read all 14 captured tool definition(s), and no name or description among them implies an irreversible operation.
  - An AI judge read all 14 captured unit(s) of tool text and found none that tries to manipulate the model reading it.
- **Capabilities**: 20/100
  - Spec-recency check failed: implements MCP spec 2024-11-05; the latest is 2026-07-28.

## Install

### How do I install the Valuation API MCP server?

Valuation API is a hosted endpoint at https://api.finance-tools.io/mcp, so there is nothing to install locally. Ready-made configuration for Claude, Cursor, VS Code, Codex and 5 more is on this page, copied from each client's own documentation.

### Claude

```bash
claude mcp add --transport http johnbehar1500-ux-valuation-api 'https://api.finance-tools.io/mcp'
```

### Cursor

```json
{
  "mcpServers": {
    "johnbehar1500-ux-valuation-api": {
      "url": "https://api.finance-tools.io/mcp"
    }
  }
}
```

### VS Code

```json
{
  "servers": {
    "johnbehar1500-ux-valuation-api": {
      "type": "http",
      "url": "https://api.finance-tools.io/mcp"
    }
  }
}
```

### Codex

```toml
[mcp_servers.johnbehar1500-ux-valuation-api]
url = "https://api.finance-tools.io/mcp"
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "johnbehar1500-ux-valuation-api": {
      "type": "remote",
      "url": "https://api.finance-tools.io/mcp",
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add johnbehar1500-ux-valuation-api --url 'https://api.finance-tools.io/mcp' --transport streamable-http
```

### Hermes

```yaml
mcp_servers:
  johnbehar1500-ux-valuation-api:
    url: "https://api.finance-tools.io/mcp"
```

### Netclaw

```json
{
  "McpServers": {
    "johnbehar1500-ux-valuation-api": {
      "Transport": "http",
      "Url": "https://api.finance-tools.io/mcp"
    }
  }
}
```

### Vellum

```bash
assistant mcp add johnbehar1500-ux-valuation-api -t streamable-http -u 'https://api.finance-tools.io/mcp'
```

### Other

```json
{
  "mcpServers": {
    "johnbehar1500-ux-valuation-api": {
      "type": "http",
      "url": "https://api.finance-tools.io/mcp"
    }
  }
}
```

The mcpServers block is a cross-client convention. Remote transports vary, so check your client's docs.

## Changelog

Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims.

### 2026-09-26 (score 73, +1)

No change was recorded against any check on this day. Stability & Change Management went from 60 to 63.

### 2026-09-25 (score 72, 0)

- [functional] We updated how we score, so this day's move reflects our rubric, not a change to the server

### 2026-09-24 (score 72, +1)

No change was recorded against any check on this day. Stability & Change Management went from 53 to 57.

### 2026-09-22 (score 71, +1)

No change was recorded against any check on this day. Stability & Change Management went from 47 to 50.

### 2026-09-20 (score 70, −2)

- [security regression] Stability: 0.57 → fail
- [security regression] A breaking change shipped without a version bump: still 0.8.0
- [security regression] Tool “irr_sensitivity” was removed
- [security] Tool “calculate_irr” rewrote its description, which is the text the model reads
- [functional] New tool “calculate_irr_sensitivity”

### 2026-09-19 (score 72, +1)

No change was recorded against any check on this day. Stability & Change Management went from 53 to 57. That category is still filling its 30-day observation window: 16 days of observed history at the previous scan, 17 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-09-16 (score 71, +1)

No change was recorded against any check on this day. Stability & Change Management went from 43 to 47. That category is still filling its 30-day observation window: 13 days of observed history at the previous scan, 14 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-09-14 (score 70, +1)

No change was recorded against any check on this day. Stability & Change Management went from 37 to 40. That category is still filling its 30-day observation window: 11 days of observed history at the previous scan, 12 at this one. The score rises as the window fills, whether or not the server changes.

## MCP tools (14)

### `calculate_irr` (~454 tokens)

Calculate the Internal Rate of Return (IRR), MOIC and an IRR sensitivity table for a single lump-sum equity investment that returns one exit value after a whole-year hold period. WHEN TO USE: you have an upfront investment amount, a single exit value and a hold period in whole years (standard PE/VC single-exit scenario) and need the annualised return, the money multiple, or a return stress-test. The result also includes a plain-language interpretation benchmarked against VC/PE/public-market return hurdles. WHEN NOT TO USE: for cash-flow streams with multiple intermediate distributions (use calculate_npv or calculate_moic on the full cash-flow array), or when you only need the sensitivity grid (use calculate_irr_sensitivity). BEHAVIOUR: pure deterministic calculation — no side effects, no network or storage access, no randomness; idempotent and non-destructive; identical inputs always produce identical outputs. IRR is solved over the cash-flow schedule [-investment, 0, ..., exit_value] via Newton-Raphson with bisection fallback. RETURNS: JSON object with concept, definition, formula, calculation (irr as a percentage string, moic as a multiple, cash_flows array), interpretation, and sensitivity (byMultiple, byHoldPeriod). PARAMETERS: initial_investment (number > 0, currency units), exit_value (number > 0, same currency units), hold_period (integer >= 1 whole years), currency (optional string: GBP default, USD, EUR, JPY, CHF — display only, no conversion).

Input parameters:

- `currency` (string): Optional display currency code. Defaults to GBP. Used only for formatting output labels — no FX conversion is performed.
- `exit_value` (number, required): Value returned at exit, same currency units as initial_investment, e.g. 250000. Must be positive.
- `hold_period` (integer, required): Holding period in whole years, e.g. 5. Must be a positive integer (1, 2, 3, ...).
- `initial_investment` (number, required): Amount invested up front, in currency units, e.g. 100000. Must be positive.

### `calculate_npv` (~371 tokens)

Calculate the Net Present Value (NPV) of an ordered cash-flow series discounted at a given rate. The first cash flow is treated as time 0 and is NOT discounted (typically the negative initial investment). WHEN TO USE: to evaluate whether an investment creates or destroys value at a required discount rate, or to compare competing projects on a present-value basis when you have a full cash-flow schedule. WHEN NOT TO USE: for a single lump-sum investment with one exit value (use calculate_irr), or when you only need a money multiple with no time value (use calculate_moic). BEHAVIOUR: pure deterministic calculation — no side effects, no network or storage access; idempotent and non-destructive; identical inputs always produce identical outputs. RETURNS: JSON object { npv: number rounded to 2dp, rate, cash_flows }. A positive NPV means the investment clears the discount-rate hurdle. PARAMETERS: rate (decimal discount rate, e.g. 0.10 = 10% — express as a decimal, never as percentage points), cash_flows (ordered number array starting at time 0; negative values are investments/outflows, positive values are distributions/inflows), e.g. [-100000, 0, 0, 0, 0, 250000].

Input parameters:

- `cash_flows` (array, required): Ordered cash flows starting at time 0 (first element is not discounted). Negative = investment/outflow, positive = distribution/inflow. Example: [-100000, 0, 0, 0, 0, 250000].
- `rate` (number, required): Discount rate as a decimal, e.g. 0.10 = 10%. Never pass percentage points (10 is invalid for 10%).

### `calculate_moic` (~278 tokens)

Calculate the Multiple on Invested Capital (MOIC): total distributions divided by total invested, with no discounting and no time value. WHEN TO USE: for a quick money-multiple answer from a cash-flow schedule when you do not need a discount rate or annualised return. WHEN NOT TO USE: when time value of money matters (use calculate_irr for annualised return, or calculate_npv for discounted value). BEHAVIOUR: pure deterministic calculation — no side effects, no network or storage access; idempotent and non-destructive. MOIC is computed as sum of positive cash flows divided by sum of absolute negative cash flows; returns 0 if there is no invested capital. RETURNS: JSON object { moic: number rounded to 2dp (e.g. 2.5 = 2.5x), cash_flows }. PARAMETERS: cash_flows (ordered number array starting at time 0; negatives are investments, positives are distributions), e.g. [-100000, 0, 0, 0, 0, 250000].

Input parameters:

- `cash_flows` (array, required): Ordered cash flows starting at time 0. Negative = invested capital, positive = distributions. Example: [-100000, 0, 0, 0, 0, 250000].

### `calculate_dcf` (~449 tokens)

Compute a Discounted Cash Flow (DCF) valuation: enterprise value from projected free cash flows plus a Gordon-growth terminal value. WHEN TO USE: to value a company or asset from its projected free cash flows, WACC and perpetual terminal growth rate (standard corporate/asset valuation). WHEN NOT TO USE: for a single-exit lump-sum investment (use calculate_irr), or when you need the discount rate itself (use calculate_wacc). BEHAVIOUR: pure deterministic calculation — no side effects, no network or storage access; idempotent and non-destructive. Terminal value uses the Gordon Growth Model; it is only defined when wacc is strictly greater than terminal_growth_rate. RETURNS: JSON object { inputs, results: { present_value, terminal_value, enterprise_value } }, each rounded to 2dp. present_value is the discounted explicit-period FCFs; enterprise_value = present_value + discounted terminal value (debt and cash are NOT netted — this is enterprise value, not equity value). PARAMETERS: free_cash_flows (array of per-period projected free cash flows, typically positive; the first element is discounted by one period), wacc (decimal, e.g. 0.10 = 10% — never pass percentage points; must be > terminal_growth_rate), terminal_growth_rate (decimal perpetual growth rate, e.g. 0.03 = 3% — never pass percentage points; must be < wacc).

Input parameters:

- `free_cash_flows` (array, required): Projected free cash flows per period, e.g. [5000000, 6000000, 7000000, 8000000, 9000000]. Typically positive; first element discounted one period.
- `terminal_growth_rate` (number, required): Perpetual terminal growth rate as a decimal, e.g. 0.03 = 3% (never pass percentage points). Must be strictly less than wacc, otherwise terminal value is undefined.
- `wacc` (number, required): Weighted average cost of capital as a decimal, e.g. 0.10 = 10% (never pass percentage points). Must be strictly greater than terminal_growth_rate.

### `calculate_wacc` (~440 tokens)

Calculate the Weighted Average Cost of Capital (WACC): the blended after-tax cost of a company's equity and debt capital, weighted by market values. WHEN TO USE: to determine the discount rate for a DCF valuation from equity market value, debt market value, costs of capital and corporate tax rate. WHEN NOT TO USE: when you already have the discount rate, or for the full valuation itself (use calculate_dcf). BEHAVIOUR: pure deterministic calculation — no side effects, no network or storage access; idempotent and non-destructive. Formula: (E/V) x Re + (D/V) x Rd x (1 - tax_rate), where V = equity_value + debt_value; returns 0 if total value is 0. RETURNS: JSON object { wacc: decimal rounded to 6dp (e.g. 0.105), wacc_percent: percentage rounded to 2dp (e.g. 10.5), inputs }. PARAMETERS: equity_value (market value of equity, >= 0), debt_value (market value of debt, >= 0), cost_of_equity (decimal, e.g. 0.12 = 12%), cost_of_debt (decimal, e.g. 0.06 = 6%), tax_rate (decimal 0-1, e.g. 0.25 = 25%). All rates are decimals, never percentage points.

Input parameters:

- `cost_of_debt` (number, required): Cost of debt as a decimal, e.g. 0.06 = 6%. Never pass percentage points.
- `cost_of_equity` (number, required): Cost of equity as a decimal, e.g. 0.12 = 12%. Never pass percentage points.
- `debt_value` (number, required): Market value of debt, >= 0, e.g. 5000000.
- `equity_value` (number, required): Market value of equity, >= 0, e.g. 10000000.
- `tax_rate` (number, required): Corporate tax rate as a decimal between 0 and 1, e.g. 0.25 = 25%.

### `calculate_irr_sensitivity` (~443 tokens)

Compute an IRR sensitivity grid across a range of exit multiples and hold periods for a single lump-sum investment. WHEN TO USE: to stress-test how the annualised return varies with exit multiple and holding period before committing to an investment. Complements calculate_irr. WHEN NOT TO USE: when you need one precise IRR for a known exit value (use calculate_irr), or a full valuation (use calculate_dcf). BEHAVIOUR: pure deterministic calculation — no side effects, no network or storage access; idempotent and non-destructive. NOTE ON GRID GEOMETRY: the byMultiple grid is computed at the SECOND hold period in hold_periods (default 5 years); the byHoldPeriod grid is computed at a 2.5x exit multiple. RETURNS: JSON object { byMultiple: { "2.0x": 14.9, ... } with IRR values as percentage numbers rounded to 1dp, byHoldPeriod: { "5y": 18.4, ... } }. PARAMETERS: initial_investment (number > 0), exit_multiples (optional array of numbers to test, default [1.5, 2.0, 2.5, 3.0, 3.5]), hold_periods (optional array of positive integers (years) to test, default [3, 5, 7, 10]).

Input parameters:

- `exit_multiples` (array): Exit multiples to test, e.g. [2.0, 2.5, 3.0, 4.0, 5.0]. Defaults to [1.5, 2.0, 2.5, 3.0, 3.5].
- `hold_periods` (array): Hold periods in whole years to test, e.g. [3, 5, 7, 10]. Defaults to [3, 5, 7, 10].
- `initial_investment` (number, required): Amount invested up front, in currency units, e.g. 100000. Must be positive.

### `calculate_earnings_yield` (~385 tokens)

Calculate the earnings yield: earnings per share divided by share price — the inverse of the P/E ratio, expressing the earnings return on the share price as a percentage. Formula: Earnings Yield = EPS / Share Price. WHEN TO USE: Use to compare equity earnings returns directly against bond yields or the risk-free rate, or as a quick value screen — a high earnings yield can signal a cheap stock. WHEN NOT TO USE: Do NOT use when EPS is negative or zero (the yield is meaningless); use it as a complement to, not a replacement for, the P/E ratio (calculate_pe_ratio). BEHAVIOUR: pure deterministic calculation — no side effects, no network or storage access; idempotent and non-destructive; identical inputs always produce identical outputs. Division by zero or non-finite inputs returns an explicit error instead of a number. RETURNS: JSON object { earnings_yield: decimal (e.g. 0.05 = 5%), earnings_yield_pct: number (e.g. 5.0), pe_ratio: number (e.g. 20 = 20x), inputs }. The P/E ratio is the reciprocal of the earnings yield, returned so a client gets both figures from one call. PARAMETERS: earnings_per_share (required): Earnings per share (trailing or forward), e.g. 2.50. Must be > 0 for a meaningful yield. share_price (required): Current share price in currency units, e.g. 50.00. Must be > 0.

Input parameters:

- `earnings_per_share` (number, required): Earnings per share (trailing or forward), e.g. 2.50. Must be > 0 for a meaningful yield.
- `share_price` (number, required): Current share price in currency units, e.g. 50.00. Must be > 0.

### `calculate_enterprise_value` (~386 tokens)

Calculate enterprise value (EV): the total value of a business to all capital providers — equity value plus net debt (total debt minus cash and equivalents). Formula: EV = Equity Value + Total Debt - Cash & Equivalents. WHEN TO USE: Use as the capital-structure-neutral measure of a company’s total value — the standard starting point for valuation multiples (EV/EBITDA, EV/Revenue) and M&A transaction values. WHEN NOT TO USE: Do NOT confuse EV with equity value (market cap) — EV is what you would pay to own the whole enterprise including its debt; use equity value for per-share figures. BEHAVIOUR: pure deterministic calculation — no side effects, no network or storage access; idempotent and non-destructive; identical inputs always produce identical outputs. Division by zero, non-finite inputs, or mathematically undefined combinations return an explicit error instead of a number. RETURNS: JSON object { enterprise_value: number (currency), inputs }. PARAMETERS: equity_value (required): Equity value / market capitalisation, e.g. 5000000. Must be >= 0. total_debt (required): Total interest-bearing debt (short + long term), e.g. 2000000. Must be >= 0. cash_and_equivalents (required): Cash and cash equivalents to subtract, e.g. 500000. Must be >= 0.

Input parameters:

- `cash_and_equivalents` (number, required): Cash and cash equivalents to subtract, e.g. 500000. Must be >= 0.
- `equity_value` (number, required): Equity value / market capitalisation, e.g. 5000000. Must be >= 0.
- `total_debt` (number, required): Total interest-bearing debt (short + long term), e.g. 2000000. Must be >= 0.

### `calculate_ev_to_ebitda` (~344 tokens)

Calculate the EV/EBITDA multiple: enterprise value divided by EBITDA — the most widely used valuation multiple for comparing companies independent of capital structure, tax and depreciation policy. Formula: EV/EBITDA = Enterprise Value / EBITDA. WHEN TO USE: Use for relative valuation of cash-generative businesses against peer multiples or transaction comps; a lower multiple may indicate relative undervaluation (or justified risk). WHEN NOT TO USE: Do NOT use when EBITDA is negative or near zero, or for early-stage companies with no meaningful EBITDA — the multiple is meaningless there (use EV/Revenue). BEHAVIOUR: pure deterministic calculation — no side effects, no network or storage access; idempotent and non-destructive; identical inputs always produce identical outputs. Division by zero, non-finite inputs, or mathematically undefined combinations return an explicit error instead of a number. RETURNS: JSON object { ev_to_ebitda: number (e.g. 8.5 = 8.5x), inputs }. PARAMETERS: enterprise_value (required): Enterprise value in currency units, e.g. 10000000. Must be > 0. ebitda (required): Earnings before interest, tax, depreciation and amortisation, e.g. 1200000. Must be > 0 for a meaningful multiple.

Input parameters:

- `ebitda` (number, required): Earnings before interest, tax, depreciation and amortisation, e.g. 1200000. Must be > 0 for a meaningful multiple.
- `enterprise_value` (number, required): Enterprise value in currency units, e.g. 10000000. Must be > 0.

### `calculate_ev_to_revenue` (~328 tokens)

Calculate the EV/Revenue (EV/Sales) multiple: enterprise value divided by revenue — a valuation multiple usable for companies with thin, negative or zero EBITDA (e.g. high-growth or pre-profit businesses). Formula: EV/Revenue = Enterprise Value / Revenue. WHEN TO USE: Use for valuing pre-profit / high-growth companies, or as a cross-check alongside EV/EBITDA for mature ones. WHEN NOT TO USE: Do NOT use revenue multiples alone — they ignore profitability entirely (a company can have a low EV/S and still destroy value); pair with margin and growth context. BEHAVIOUR: pure deterministic calculation — no side effects, no network or storage access; idempotent and non-destructive; identical inputs always produce identical outputs. Division by zero, non-finite inputs, or mathematically undefined combinations return an explicit error instead of a number. RETURNS: JSON object { ev_to_revenue: number (e.g. 3.2 = 3.2x), inputs }. PARAMETERS: enterprise_value (required): Enterprise value in currency units, e.g. 10000000. Must be > 0. revenue (required): Revenue (net sales) over the trailing period, e.g. 3100000. Must be > 0.

Input parameters:

- `enterprise_value` (number, required): Enterprise value in currency units, e.g. 10000000. Must be > 0.
- `revenue` (number, required): Revenue (net sales) over the trailing period, e.g. 3100000. Must be > 0.

### `calculate_capm_cost_of_equity` (~489 tokens)

Calculate the cost of equity using the Capital Asset Pricing Model (CAPM): the risk-free rate plus beta times the market risk premium. Formula: Re = Rf + beta x (Rm - Rf). WHEN TO USE: Use to estimate the required return on equity — an input to WACC (calculate_wacc) and DCF discount rates, or as a standalone return hurdle. WHEN NOT TO USE: Do NOT use for companies where beta is a poor risk measure (private companies without a traded beta — consider building up from comparable betas via calculate_unlever_beta / calculate_relever_beta first). BEHAVIOUR: pure deterministic calculation — no side effects, no network or storage access; idempotent and non-destructive; identical inputs always produce identical outputs. Division by zero, non-finite inputs, or mathematically undefined combinations return an explicit error instead of a number. RETURNS: JSON object { cost_of_equity: decimal (e.g. 0.115 = 11.5%), cost_of_equity_pct: number (e.g. 11.5), inputs }. PARAMETERS: risk_free_rate (required): Risk-free rate as a decimal, e.g. 0.04 = 4% (typically the 10-year government bond yield; never pass percentage points). beta (required): Equity beta (levered, if the company has debt), e.g. 1.2. Use unlevered/relevered betas when comparing capital structures. market_return (required): Expected market return (Rm) as a decimal, e.g. 0.10 = 10% (never pass percentage points). The market risk premium is computed internally as Rm - Rf.

Input parameters:

- `beta` (number, required): Equity beta (levered, if the company has debt), e.g. 1.2. Use unlevered/relevered betas when comparing capital structures.
- `market_return` (number, required): Expected market return (Rm) as a decimal, e.g. 0.10 = 10% (never pass percentage points). The market risk premium is computed internally as Rm - Rf.
- `risk_free_rate` (number, required): Risk-free rate as a decimal, e.g. 0.04 = 4% (typically the 10-year government bond yield; never pass percentage points).

### `calculate_unlever_beta` (~470 tokens)

Unlever a (levered) equity beta to its asset beta using the Hamada formula — removing the financial-risk effect of debt so betas of companies with different capital structures can be compared. Formula: Beta(unlevered) = Beta(levered) / (1 + (1 - tax rate) x Debt/Equity). WHEN TO USE: Use when valuing a private company or a deal with a different capital structure than the public comparable — unlever the comps’ betas, average them, then relever at your target structure. WHEN NOT TO USE: Do NOT unlever with an inconsistent tax rate or debt/equity ratio — the result is only as clean as its inputs; for companies with significant non-debt liabilities consider a more advanced formula. BEHAVIOUR: pure deterministic calculation — no side effects, no network or storage access; idempotent and non-destructive; identical inputs always produce identical outputs. Division by zero, non-finite inputs, or mathematically undefined combinations return an explicit error instead of a number. RETURNS: JSON object { unlevered_beta: number (e.g. 0.85), inputs }. PARAMETERS: levered_beta (required): The observed (levered) equity beta of the comparable company, e.g. 1.2. Must be > 0. tax_rate (required): Corporate tax rate as a decimal between 0 and 1, e.g. 0.25 = 25%. debt_to_equity (required): Debt-to-equity ratio of the company whose beta is being unlevered (market values preferred), e.g. 0.5 = 0.5x. Must be >= 0.

Input parameters:

- `debt_to_equity` (number, required): Debt-to-equity ratio of the company whose beta is being unlevered (market values preferred), e.g. 0.5 = 0.5x. Must be >= 0.
- `levered_beta` (number, required): The observed (levered) equity beta of the comparable company, e.g. 1.2. Must be > 0.
- `tax_rate` (number, required): Corporate tax rate as a decimal between 0 and 1, e.g. 0.25 = 25%.

### `calculate_relever_beta` (~431 tokens)

Relever an unlevered (asset) beta to a target capital structure using the Hamada formula — restoring financial risk for the specific debt/equity mix of the company or deal being valued. Formula: Beta(levered) = Beta(unlevered) x (1 + (1 - tax rate) x Debt/Equity). WHEN TO USE: Use AFTER unlevering comparable betas: apply the average unlevered beta to your target company’s (or transaction’s) capital structure to obtain the beta for WACC. WHEN NOT TO USE: Do NOT relever onto an unrealistic target structure — extreme leverage produces extreme betas that may overstate risk; sanity-check the resulting cost of equity. BEHAVIOUR: pure deterministic calculation — no side effects, no network or storage access; idempotent and non-destructive; identical inputs always produce identical outputs. Division by zero, non-finite inputs, or mathematically undefined combinations return an explicit error instead of a number. RETURNS: JSON object { levered_beta: number (e.g. 1.15), inputs }. PARAMETERS: unlevered_beta (required): Unlevered (asset) beta, e.g. 0.85. Must be > 0. tax_rate (required): Corporate tax rate as a decimal between 0 and 1, e.g. 0.25 = 25%. debt_to_equity (required): Target debt-to-equity ratio (market values preferred), e.g. 0.6 = 0.6x. Must be >= 0.

Input parameters:

- `debt_to_equity` (number, required): Target debt-to-equity ratio (market values preferred), e.g. 0.6 = 0.6x. Must be >= 0.
- `tax_rate` (number, required): Corporate tax rate as a decimal between 0 and 1, e.g. 0.25 = 25%.
- `unlevered_beta` (number, required): Unlevered (asset) beta, e.g. 0.85. Must be > 0.

### `calculate_equity_value_from_enterprise_value` (~396 tokens)

Calculate equity value from enterprise value: the value attributable to common shareholders, derived by subtracting net debt (total debt minus cash) from enterprise value — the reverse of the EV bridge. Formula: Equity Value = Enterprise Value - Total Debt + Cash & Equivalents. WHEN TO USE: Use when you hold enterprise value (e.g. from a DCF or an EV multiple) and need the implied equity value / market capitalisation for per-share or acquisition-equity figures. WHEN NOT TO USE: Do NOT use when you already have market capitalisation directly; and do NOT net non-interest-bearing liabilities — only interest-bearing total debt is subtracted. BEHAVIOUR: pure deterministic calculation — no side effects, no network or storage access; idempotent and non-destructive; identical inputs always produce identical outputs. Division by zero, non-finite inputs, or mathematically undefined combinations return an explicit error instead of a number. RETURNS: JSON object { equity_value_from_enterprise_value: number (currency), inputs }. PARAMETERS: enterprise_value (required): Enterprise value in currency units, e.g. 10000000. Must be >= 0. total_debt (required): Total interest-bearing debt (short + long term), e.g. 2000000. Must be >= 0. cash_and_equivalents (required): Cash and cash equivalents to add back, e.g. 500000. Must be >= 0.

Input parameters:

- `cash_and_equivalents` (number, required): Cash and cash equivalents to add back, e.g. 500000. Must be >= 0.
- `enterprise_value` (number, required): Enterprise value in currency units, e.g. 10000000. Must be >= 0.
- `total_debt` (number, required): Total interest-bearing debt (short + long term), e.g. 2000000. Must be >= 0.

## Diagnostics

Captured diagnostic sections: TLS, DNSSEC, Authorisation, Transports. The full working is on the page: https://verifymcp.io/servers/johnbehar1500-ux-valuation-api/api#diagnostics

## Score history

- 2026-09-27: 73
- 2026-09-26: 73
- 2026-09-25: 72
- 2026-09-24: 72
- 2026-09-23: 71
- 2026-09-22: 71
- 2026-09-21: 70
- 2026-09-20: 70
- 2026-09-19: 72
- 2026-09-18: 71
- 2026-09-17: 71
- 2026-09-16: 71
- 2026-09-15: 70
- 2026-09-14: 70
- 2026-09-13: 69
- 2026-09-12: 69
- 2026-09-11: 68
- 2026-09-10: 68
- 2026-09-09: 67
- 2026-09-08: 67
- 2026-09-07: 66
- 2026-09-06: 66
- 2026-09-05: 63
- 2026-09-04: 63
- 2026-09-03: 56
- 2026-09-02: 56

## Common questions

### What is the Valuation API MCP server?

Valuation API is an MCP server listed in the public MCP registry as io.github.johnbehar1500-ux/valuation-api. Deterministic finance tools for AI agents, IRR, NPV, MOIC, DCF, WACC and sensitivity. This page covers its hosted endpoint (https://api.finance-tools.io/mcp).

### Is the Valuation API MCP server safe to use?

Valuation API scores 73 out of 100 on VerifyMCP. That is a record of what we were able to check automatically, not an endorsement. The category breakdown on this page shows every signal behind the number, including the ones we could not confirm.

### What tools does the Valuation API MCP server expose?

Valuation API exposes 14 tools: calculate_irr, calculate_npv, calculate_moic, calculate_dcf, calculate_wacc, and 9 more. Their descriptions and schemas cost roughly 5,664 tokens of context every time the server is loaded.

### Does the Valuation API MCP server require authentication?

No. We connected to Valuation API without credentials and it answered, so anything it exposes is reachable by anyone who knows the address.

### Is the Valuation API MCP server still maintained?

Valuation API is still listed as active in the MCP registry. We last reached this channel on 27 September 2026. Those dates come from our own scans of the registry and the channel itself, not from anything the publisher announced.

## Links

- Remote endpoint: https://api.finance-tools.io/mcp
- Repository: https://github.com/johnbehar1500-ux/valuation-api
- Changelog RSS feed: https://verifymcp.io/servers/johnbehar1500-ux-valuation-api/api.xml
- Changelog JSON feed: https://verifymcp.io/servers/johnbehar1500-ux-valuation-api/api.json
- HTML version of this page: https://verifymcp.io/servers/johnbehar1500-ux-valuation-api/api