VaR calculator
A 1,000,000 portfolio with 20% annual volatility has a 10-day value at risk of 65,532.54 at 95% confidence: the loss to treat as the worst case over that period. Enter value, volatility, horizon and confidence. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Portfolio value
- 1,000,000
- Volatility
- 20
- Time horizon
- 10
- Confidence level
- 95
- Trading days
- 252
- Z score
- 1.644854
- Horizon years
- 0.039683
- Scaled volatility
- 0.039841
Value at risk, or VaR, is the market-risk figure that answers one planning question: over a stated holding period, how large a loss should you treat as the worst case at a chosen confidence level? Risk desks, treasurers, exam candidates, and landing-page readers already hold four numbers — current portfolio value, annual volatility, a time horizon in days, and a confidence such as ninety-five or ninety-nine percent — and they need the parametric variance-covariance loss, not a historical simulation and not a Monte Carlo path. This value at risk calculator scales annual volatility to the holding period with the square-root-of-time rule, multiplies by the standard-normal z-score for the confidence, and returns the maximum expected loss in the same units as the book.
What parametric value at risk means and how the loss is computed
Parametric value at risk, also called variance-covariance VaR, is the closed-form loss that a mean-zero Gaussian return model assigns to a chosen confidence level. The loss quantile is that scaled volatility times the standard-normal z-score z_α equal to the inverse CDF Φ⁻¹(α) for confidence α, so VaR equals V × σ × z_α × √(t/T).
A one-million book with twenty percent annual volatility, a ten-day horizon, and ninety-five percent confidence therefore uses z of about 1.64485 and √(10/252) of about 0.1992, and the parametric loss is about 65,535 in the same currency as V. When the horizon is one trading day the square-root factor collapses to 1/√252. When confidence rises from ninety-five to ninety-nine percent, z rises from about 1.64 to about 2.33 and VaR scales by that ratio; the time scaling stays the square-root-of-time rule rather than a linear day count.
This identity is not a historical-simulation VaR and not a Monte Carlo VaR: it does not consume a return path, a copula, or a random seed. It also does not add an expected-return drift, so the figure is the textbook mean-zero parametric loss used in desk calculators, FRM worksheets, and Basel-style ten-day scalings. Negative volatility is not a standard deviation, so the solver refuses that input rather than taking an absolute value in silence.
Zero volatility is well-defined and returns a zero loss.
What you can do with it
Desk limits and ten-day regulatory scalings
Turn a current mark, annual volatility, and a one-day or ten-day horizon into parametric VaR at ninety-five or ninety-nine percent for limit memos and Basel-style square-root-of-time checks.
Exam worksheets and FRM / CFA drills
Check a worked parametric value-at-risk item: z-score, scaled period volatility, and the maximum expected loss from the same four inputs the question already states.
FAQ
How is parametric value at risk calculated?
VaR = V × σ × z × √(t/T). The response is the maximum expected loss in the same units as V.
Which confidence levels can I use?
Any percent strictly between 50 and 100 (95, 99) or a decimal in (0.5, 1) such as 0.95. Typical market-risk choices are 90, 95, and 99 percent; each sets z = Φ⁻¹(α).
What happens if volatility is negative or zero?
Negative volatility is not a standard deviation, so it is refused instead of being turned positive in silence. Zero volatility is valid and simply gives a loss of zero.
Why isn't a 10-day VaR ten times the 1-day figure?
Because volatility grows with the square root of time, not with the day count. The calculator scales annual volatility by the square root of the horizon over 252 trading days.
Is this historical or Monte Carlo VaR?
Neither. It is the parametric, mean-zero formula: value times volatility times the z-score for your confidence, scaled to the horizon. It uses no return history, no random paths and no expected-return drift.
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/var \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"portfolio_value":1000000,"volatility":20,"time_horizon":10,"confidence_level":95}'const res = await fetch("https://api.kit.forhosting.com/fin/var", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"portfolio_value": 1000000,
"volatility": 20,
"time_horizon": 10,
"confidence_level": 95
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/fin/var",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"portfolio_value": 1000000,
"volatility": 20,
"time_horizon": 10,
"confidence_level": 95
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/fin/var", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"portfolio_value":1000000,"volatility":20,"time_horizon":10,"confidence_level":95}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"portfolio_value":1000000,"volatility":20,"time_horizon":10,"confidence_level":95}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/fin/var", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"portfolio_value": 1000000,
"volatility": 20,
"time_horizon": 10,
"confidence_level": 95
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "fin.var",
"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.
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
When volatility is negative the task fails with invalid_input instead of inventing a loss.
What parametric value at risk means and how the loss is computed
If the current mark of the book is V, annual volatility as a decimal is σ, the holding period is t days, and a year contains T trading days — two hundred fifty-two on this endpoint unless you override trading_days — then the period standard deviation is σ times the square root of t over T.
Input contract, response shape, and error behaviour
A confidence that does not sit strictly above fifty percent and strictly below one hundred percent is rejected so the z-score stays a positive finite quantile. Pair the result with your own return series if you need historical or Monte Carlo VaR; start here when the product question is a transparent four-input parametric loss for a page, a worksheet, or a batch of scenarios that already share one annual volatility. POST a JSON body with four required finite numbers: portfolio_value, the current mark in currency units, zero or greater (aliases value, amount, portfolio, principal, pv); volatility, the annual standard deviation of returns as a percent such as twenty for twenty percent (aliases sigma, vol, annual_volatility, stdev); time_horizon, the holding period in days such as one or ten (aliases horizon, days, holding_period, t); and confidence_level, either a percent between fifty and one hundred exclusive such as ninety-five, or a decimal in (0.5, 1) exclusive such as 0.95 (aliases confidence, alpha, level, cl). Optional trading_days defaults to two hundred fifty-two, the market-risk year used as T in the square-root factor; optional decimals is an integer from zero through twelve that controls half-up rounding (default six). Each required field may arrive as a JSON number or as a numeric string; missing fields, empty strings, booleans, and non-finite values fail with invalid_input naming the field and are not billed. A negative portfolio_value is rejected for the same reason a current mark is not a short-sale remainder in this identity. A non-positive time_horizon is rejected because a holding period must be a positive number of days. On success the body echoes portfolio_value, volatility, time_horizon, confidence_level as a percent, and trading_days; it adds z_score, horizon_years (t/T), scaled_volatility (the period standard deviation as a decimal), value_at_risk as the loss in the same units as the book, value_at_risk_percent as that loss over V times one hundred, and a formula string restating VaR = V × σ × z × √(t/T).
Where a value at risk calculator earns its keep
Educators teaching why ninety-nine percent VaR is larger than ninety-five percent VaR — and why a negative volatility is not a defined standard deviation — can seed classroom examples that fail honestly instead of taking an absolute value. Failed validation, including a negative volatility, does not consume balance. Treasury teams comparing a one-day desk limit with a ten-day regulatory scaling can post the same book and volatility twice, change only time_horizon, and quote a stable value_at_risk under the square-root-of-time rule. FRM and CFA candidates checking a worked parametric VaR item can pin z_score and the scaled volatility next to the loss so a wrong annualization basis is visible instead of hidden inside a single number. Because the implementation is tier A parse, every successful call costs the published $0.002 base price with no model tokens and no outbound network. Keep the four required fields finite, keep volatility at zero or above, pin the rounded value_at_risk in tests, and you get reproducible parametric losses for widgets, CMS embeds, and edge workers without standing up a risk-engine service of your own.
Integration use cases
Landing widgets and scenario batches
Embed a free browser VaR calculator on a risk explainer, or post many (value, vol, horizon, confidence) tuples from a script and pin value_at_risk in tests.
Technical questions
What happens if volatility is negative?
The task fails with invalid_input. A standard deviation of returns cannot be negative, so the calculator does not take an absolute value or invent a loss, and the call is not billed.
Is the time horizon in days or years?
Days. One-day VaR uses time_horizon 1; a Basel-style ten-day figure uses 10. Annual volatility is scaled by √(t/trading_days), with trading_days defaulting to 252.
What does the value at risk calculator cost?
The browser tool is free. API requests use prepaid KIT balance at $0.002 per successful call; invalid input, including negative volatility, is not billed.