Expected return calculator
A 60% equity sleeve expected to earn 10% plus 40% in bonds at 4% gives a portfolio expected return of 7.6%, not the simple average of 7%. Each holding's contribution is shown too. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
The expected return of a portfolio is the single number that combines every holding's forecast into one figure: each asset's expected return is multiplied by its portfolio weight, and those products are added. Analysts, students, and allocation tools look up this weighted sum whenever they need a hurdle for a mix, a comparison across model portfolios, or a check that a proposed rebalance still meets a return target.
What portfolio expected return means and how the weights work
The expected return of a portfolio is the weight-weighted mean of the individual expected returns. Write each allocation as a weight that sums to one across the book and each forecast as an annual percent, then add the products. Because the weights are portfolio fractions, a sixty percent equity sleeve at ten percent dominates a forty percent bond sleeve at four percent: the mix expected return is six plus one point six, or seven point six percent, not the unweighted average of ten and four.
That distinction is why people search for a portfolio expected return calculator instead of adding forecast percents and dividing by the count of names. The identity is the same one used in mean-variance textbooks, IPS drafts, and model-portfolio fact sheets: the return that, applied to a unit of wealth, produces the same expected-return mass as the separate holdings. When two assets share an expected return the portfolio figure equals that return regardless of how the weight is split.
When weights differ, the heavier sleeve owns more of the result, which is exactly what an allocation memo needs before anyone talks about risk or tracking error.
What you can do with it
Model-portfolio and fact-sheet pages
Let visitors enter sleeve weights and published expected returns and show one portfolio expected return next to the mix, so a 60/40 fact sheet is a live identity instead of a static footnote.
Classroom and CFA-style homework
Mark weighted-expected-return items with a deterministic oracle that rejects a book whose weights do not sum to one and never silently renormalizes a broken allocation.
FAQ
How is portfolio expected return calculated?
Weights are fractions of the book (0.6 means 60%). Expected returns are percents (10 means 10%). A larger weight pulls the mix more than a smaller one.
What happens if the weights do not sum to one?
Portfolio expected return is undefined for a broken allocation: leftover weight would be an unnamed residual, and a sum above one would double-count capital. Empty lists and weight sums other than 1 are never returned as a success.
Do I enter expected returns as percents or decimals?
As percents, matching other return calculators here. Send 10 for a 10% expected return, not 0.10. Each holding also needs a weight as a fraction (0.6, not 60) so the list can sum to 1.
Can a weight be negative?
Yes. A negative weight is a short sleeve. Expected returns may also be negative for a forecast loss. The identity stays well-defined as long as the weights still sum to one.
Does it also calculate portfolio risk or the Sharpe ratio?
No. It gives the weighted expected return and each holding's contribution, but no variance, volatility or Sharpe ratio. It also does not estimate returns from past prices: you supply the forecasts.
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/expected-return \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"assets":[{"name":"Equities","weight":0.6,"expected_return":10},{"name":"Bonds","weight":0.4,"expected_return":4}]}'const res = await fetch("https://api.kit.forhosting.com/fin/expected-return", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"assets": [
{
"name": "Equities",
"weight": 0.6,
"expected_return": 10
},
{
"name": "Bonds",
"weight": 0.4,
"expected_return": 4
}
]
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/fin/expected-return",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"assets": [
{
"name": "Equities",
"weight": 0.6,
"expected_return": 10
},
{
"name": "Bonds",
"weight": 0.4,
"expected_return": 4
}
]
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/fin/expected-return", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"assets":[{"name":"Equities","weight":0.6,"expected_return":10},{"name":"Bonds","weight":0.4,"expected_return":4}]}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"assets":[{"name":"Equities","weight":0.6,"expected_return":10},{"name":"Bonds","weight":0.4,"expected_return":4}]}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/fin/expected-return", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"assets": [
{
"name": "Equities",
"weight": 0.6,
"expected_return": 10
},
{
"name": "Bonds",
"weight": 0.4,
"expected_return": 4
}
]
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "fin.expected_return",
"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_items | 100 |
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
This expected return calculator accepts a list of assets with weights that must sum to one and expected returns as annual percents, applies the identity E(R_p) equals the sum of w_i times E(R_i), and returns the portfolio expected return as a percent and as a decimal. If the weights do not sum to one the task fails with invalid_input instead of silently renormalizing a broken allocation.
What portfolio expected return means and how the weights work
Algebraically that is E(R_p) equals Σ(w_i × E(R_i)). This endpoint does not fetch live prices, does not estimate expected returns from history, and does not compute variance or Sharpe. It answers one question honestly: if these weights and these expected returns are the mix, what single expected return describes the book.
Input contract, response shape, and error behaviour
The distinctive failure is a weight sum other than one: if the fractions do not add to 1 within a tolerance of 1e-8, the task fails rather than secretly rescaling the book or returning a figure that pretends the leftover cash does not exist. Weights may be negative for a short sleeve, and expected returns may be negative for a forecast loss; both remain well-defined as long as the weights still sum to one. Example: equities at weight 0.6 and ten percent plus bonds at weight 0.4 and four percent yields a portfolio expected return of seven point six percent, or 0.076 as a decimal. POST a JSON body with a single required field assets: a non-empty array of objects. Each object must include weight (finite number, a fraction of the book such as 0.6 for sixty percent) and expected_return (finite number, annual expected return as a percent such as 10 for ten percent). Aliases holdings, positions, portfolio, and list are accepted for the array. At most one hundred assets are allowed per call. An empty array, a missing assets field, a non-array value, or an asset object lacking weight or expected_return fails with invalid_input and is not billed. On success the body includes asset_count; weight_sum (should read as 1); expected_return as a decimal ratio; expected_return_percent; an assets array of records each carrying name, weight, expected_return, and contribution_percent (weight times that asset's expected return); and a formula string restating the identity. Pair the response with your own forecasts; this endpoint measures the weighted sum only.
Where a portfolio expected return calculator earns its keep
Failed validation does not consume balance. The capability never invents forecasts from price history or a covariance matrix; those estimates belong in your data layer, and this calculator only applies the weighted-sum identity once you supply them. Advisors and IPS worksheets can call the same pure module from the browser for free previews and from the API for stored files, guaranteeing that the figure a client saw on the landing page matches the figure stored after a rebalance. Educators and CFA-style homework need a deterministic oracle for E(R_p) equals the sum of w_i times E(R_i), including the short-weight case and the failure when weights do not sum to one, so a buggy grader cannot treat a broken allocation as success. Spreadsheet add-ons and allocation apps often already store ticker rows with target weights and analyst expected returns; posting that list once yields the portfolio figure plus each holding's contribution_percent for a stacked chart. Keep the list under one hundred assets, pin expected_return and expected_return_percent in tests, and you get a reproducible portfolio expected return for widgets, classrooms, and edge workers without standing up a factor-model library of your own.
Integration use cases
Rebalance and IPS worksheets
Post stored target weights and analyst forecasts once to fill an expected-return field and a contribution breakdown, then compare the mix before and after a proposed trade.
Technical questions
What does the expected return calculator cost?
The browser tool is free. API requests use prepaid KIT balance at $0.002 per successful call; invalid input is not billed.