EMV calculator
A demand tree with a 0.2 chance of earning 100,000, a 0.5 chance of 40,000 and a 0.3 chance of losing 20,000 has an expected monetary value of 34,000. Enter each outcome's probability and payoff to weigh the decision. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
The expected monetary value, or EMV, of a decision is the probability-weighted sum of the payoffs attached to each mutually exclusive outcome. Decision analysts, project-risk leads, and operators comparing a launch, a hedge, or a self-insure choice all need that single cash figure before they pick a path. This expected monetary value calculator accepts a list of outcomes, each with a probability in the unit interval and a monetary payoff that may be a gain or a loss, multiplies each pair, and returns the weighted sum together with the per-outcome contributions.
What expected monetary value means and how the weighted sum is formed
The expected monetary value of a discrete set of outcomes is the sum, over every branch, of probability times payoff. A two-branch launch with a forty percent chance of earning fifty thousand and a sixty percent chance of losing ten thousand therefore has expected monetary value of twenty thousand minus six thousand, or fourteen thousand in the same currency as the payoffs.
A three-branch demand tree with probabilities two tenths, one half, and three tenths and payoffs of one hundred thousand, forty thousand, and negative twenty thousand has EMV of thirty-four thousand. The sign of that result is the decision signal against a status-quo payoff of zero: a strictly positive EMV says the lottery is better than walking away in expected-cash terms, while a negative EMV says the expected cash is a loss.
EMV is not a forecast of what will happen on the next trial, and it is not a von Neumann–Morgenstern utility; it is the first-moment cash equivalent of the discrete lottery you supplied. When two alternatives are compared, the cash-first ranking is the higher expected monetary value, all else equal. Nested decision trees collapse the same way: compute EMV at each chance node, then pick the alternative with the larger EMV at each decision node.
This calculator evaluates one chance node at a time. You send the branches of that node and receive the node's expected monetary value with a contribution for every branch so a reviewer can see which outcomes pull the total up or down.
Where an expected monetary value calculator earns its keep
A launch decision with a hit payoff and a miss payoff becomes a go or no-go once EMV is stacked against doing nothing. A risk register that already stores probability and impact for a few discrete scenarios can post those rows and pin the expected exposure instead of averaging impacts as if they were equally likely.
Educators and professional-exam prep need a deterministic oracle for homework that asks students to compute EMV as the sum of probability times payoff, including the case of a loss branch and the case where probabilities fail to add to one. Failed validation does not consume balance.
Keep each probability inside the unit interval, keep the list exhaustive so the chances add to one, pin the rounded emv field in tests, and you get reproducible expected monetary values for widgets, classrooms, and production without standing up a decision-tree library of your own. The capability never invents a probability from historical frequencies or a payoff from a cash-flow model; those estimates belong in your data layer, and this calculator only applies the weighted-sum identity once you supply the branches.
Compare two alternatives by running each chance node separately and choosing the larger EMV; fold a tree by substituting each computed EMV as the payoff of the parent branch.
What you can do with it
Product launch go or no-go
Turn a hit payoff, a miss payoff, and their probabilities into one expected monetary value and compare it with doing nothing.
Risk-register expected exposure
Post discrete probability and impact rows from a register and pin the expected cash exposure instead of treating every scenario as equally likely.
FAQ
What happens if probabilities do not sum to one?
The calculator never renormalizes a list whose chances do not add to one, so a missing branch or a typing error cannot silently change the result. Failed validation is not billed.
Can payoffs be negative?
Yes. A negative payoff is a loss (sunk launch cost, claim, write-off). EMV can be negative when expected losses outweigh expected gains, which is the signal to reject the lottery against a zero status quo.
Do I need a label on every outcome?
No. label is optional and used only in the contributions array for display. probability and payoff are required on every row.
How is expected monetary value calculated?
Multiply each outcome's payoff by its probability and add the products. The calculator also shows each product, so you can see which outcomes pull the total up or down.
Does EMV predict what will actually happen?
No. It is the probability-weighted average cash of the outcomes you entered, not a forecast of the next result, and it does not measure how you feel about risk. Use it to rank alternatives in expected cash terms.
Related tools
For developers — API access
Everything on this page is available programmatically. This section is for teams who want to wire it into their own systems; everyone else can just use the tool above.
API endpoint
Prefer to automate it? One authenticated POST creates the task; the result comes back by webhook or a signed link. The same capability also runs here on the web, by email and from Telegram — and soon from our app too.
Call it from your stack
curl -X POST https://api.kit.forhosting.com/fin/emv \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"outcomes":[{"label":"High demand","probability":0.2,"payoff":100000},{"label":"Base demand","probability":0.5,"payoff":40000},{"label":"Low demand","probability":0.3,"payoff":-20000}]}'const res = await fetch("https://api.kit.forhosting.com/fin/emv", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"outcomes": [
{
"label": "High demand",
"probability": 0.2,
"payoff": 100000
},
{
"label": "Base demand",
"probability": 0.5,
"payoff": 40000
},
{
"label": "Low demand",
"probability": 0.3,
"payoff": -20000
}
]
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/fin/emv",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"outcomes": [
{
"label": "High demand",
"probability": 0.2,
"payoff": 100000
},
{
"label": "Base demand",
"probability": 0.5,
"payoff": 40000
},
{
"label": "Low demand",
"probability": 0.3,
"payoff": -20000
}
]
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/fin/emv", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"outcomes":[{"label":"High demand","probability":0.2,"payoff":100000},{"label":"Base demand","probability":0.5,"payoff":40000},{"label":"Low demand","probability":0.3,"payoff":-20000}]}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"outcomes":[{"label":"High demand","probability":0.2,"payoff":100000},{"label":"Base demand","probability":0.5,"payoff":40000},{"label":"Low demand","probability":0.3,"payoff":-20000}]}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/fin/emv", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"outcomes": [
{
"label": "High demand",
"probability": 0.2,
"payoff": 100000
},
{
"label": "Base demand",
"probability": 0.5,
"payoff": 40000
},
{
"label": "Low demand",
"probability": 0.3,
"payoff": -20000
}
]
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "fin.emv",
"status": "queued",
"_links": {
"result": "/tasks/tsk_…/result"
}
}The API is asynchronous: the call returns a task_id immediately and the result arrives by webhook. Polling is capped at 1 req/s per task.
Pricing
Published price — no tokens, no invented credits. A failed task is never charged.
Limits
max_outcomes | 10000 |
Errors
| HTTP | Code | Meaning |
|---|---|---|
401 | unauthorized | Missing or invalid API key. |
402 | insufficient_balance | Your balance doesn't cover the task price. |
404 | unknown_type | That task type doesn't exist. |
429 | rate_limited | Too many requests. Use the webhook instead of polling. |
Technical notes
If the probabilities do not add to one, the task fails with invalid_input instead of silently renormalizing a malformed chance node.
What expected monetary value means and how the weighted sum is formed
In the language of decision analysis that appears in project-management risk chapters, CFA primers, and operations-research textbooks, each mutually exclusive and collectively exhaustive state of the world carries a chance p_i and a cash consequence x_i; EMV equals the sum of p_i times x_i. This endpoint does not discount future cash, apply a tax shield, or convert currency, and it does not fetch live probabilities from a market. It applies the identity so homework keys, risk registers, and automation share one auditable number.
Input contract, response shape, and error behaviour
Each object must carry probability, a finite number in the closed unit interval from zero through one, and payoff, a finite monetary amount that may be positive, negative, or zero. A row that is not a plain object, a missing or non-finite probability, a probability outside zero through one, or a missing or non-finite payoff fails the same way and names the index. Failed validation is not billed. Example: probabilities two tenths, one half, and three tenths with payoffs one hundred thousand, forty thousand, and negative twenty thousand yield contributions twenty thousand, twenty thousand, and negative six thousand, and an expected monetary value of thirty-four thousand. POST a JSON body with the required field outcomes, a non-empty array of objects. Optional label names the branch for display and also accepts the aliases name and outcome. The array itself accepts aliases scenarios and branches. Probability on a row accepts aliases p and prob; payoff accepts aliases amount and value. Missing outcomes, a non-array, an empty list, or more than ten thousand rows fail with invalid_input naming the field. If that sum is not one within a tolerance of one billionth, the task fails with a message that probabilities must sum to one; the endpoint never renormalizes a malformed tree, because silent rescaling would hide a missing branch or a typing error and bill a number nobody meant. On success the body includes n, the number of outcomes; sum_probabilities, which will be one within rounding; emv, the weighted sum rounded to twelve decimal places for a stable contract across runtimes; contributions, an array that echoes each probability, payoff, contribution equal to probability times payoff, and label when one was supplied; and a formula string restating that EMV equals the sum of p_i times payoff_i. Pair the response with your own tree layout if you need a drawing; this endpoint computes the chance-node value only and does not emit plots or a full fold-back of nested decisions.
Where an expected monetary value calculator earns its keep
Spreadsheet owners who currently multiply columns by hand can call the endpoint from a notebook, a workflow, or an edge worker and freeze the goldens whenever the probability column changes. That is the entire method, and this endpoint is the arithmetic at a single node.
Integration use cases
Classroom and exam EMV keys
Mark decision-analysis items that ask for Σ p_i × payoff_i, including loss branches and lists whose probabilities do not sum to one.
Technical questions
How is expected monetary value (EMV) calculated?
EMV is the sum of probability times payoff over every mutually exclusive outcome: EMV = Σ p_i × payoff_i. Send those pairs as outcomes; the response returns emv and each branch contribution.
What does the expected monetary value calculator cost?
The browser tool is free. API requests use prepaid KIT balance at $0.002 per successful call; invalid input is not billed.