Dividend Reinvestment (DRIP) Calculator
This dividend reinvestment calculator projects how an existing stock or fund holding may grow when every cash dividend automatically buys more fractional shares.
Run — free
Enter your starting share count and price, a fixed annual dividend yield, an assumed annual price growth rate, the investment horizon, and the payment frequency. The result shows the shares accumulated, dividends reinvested, future share price, final holding value, and total return. It is designed for transparent scenario planning rather than prediction, so every result follows the rates you supply.
Understand what the DRIP projection represents
A dividend reinvestment plan, commonly called a DRIP, uses each dividend payment to purchase additional shares instead of paying cash out to the investor. Those new shares can receive later dividends, creating a compounding effect in the share count even when no new money is contributed. This calculator begins with the number of shares and market price you enter. It then divides the annual dividend yield into equal payments, increases the price at an equivalent periodic growth rate, calculates the dividend on all shares currently held, and reinvests that amount at the current projected price. Fractional shares are allowed, because many modern reinvestment programs support them and because rounding every purchase to whole shares would systematically understate growth. The result separates the starting and ending share counts, starting and ending prices, cumulative cash dividends reinvested, final value, and total return. It therefore makes two sources of change visible: the assumed movement in the security's price and the expanding ownership created by reinvestment. This is a mathematical scenario, not a forecast or a recommendation to buy a particular security.
How yield, price growth, and payment frequency interact
The annual dividend yield is treated as fixed and is applied in equal portions at the payment frequency you choose. For quarterly dividends, one fourth of the annual yield is applied at each of four period ends. The effective annual price growth rate is converted into a matching periodic rate, so four quarterly price steps compound to the annual assumption. At each period end, price growth is applied before that period's dividend is calculated and reinvested. Because the dividend is modeled as a percentage of the current holding value and the purchase occurs at the same price, the immediate share increase depends on the periodic yield; price growth still matters greatly because it changes the value of every original and reinvested share. More frequent reinvestment produces slightly more dividend compounding under this simplified equal-payment model. A negative price-growth rate is permitted as long as it remains above a complete loss, allowing stress scenarios in which share count rises while portfolio value falls. The calculation keeps full floating-point precision throughout all periods and rounds only the returned numbers. Taxes, brokerage restrictions, fees, dividend cuts, irregular payment dates, and delays between payment and purchase are intentionally excluded.
Choose realistic assumptions and interpret the outputs
Start with the shares you already own and the current price per share; their product is the starting value. Use a dividend yield that is plausible for the security and remember that published trailing, indicated, and forward yields describe different evidence. Enter price growth separately rather than treating total historical return as price growth, because a total-return figure may already include reinvested dividends and would double count them here. Match the payment frequency to the expected distribution schedule: quarterly is common for many companies, while monthly and annual schedules also occur. Consider running several scenarios instead of relying on one precise-looking answer. A conservative case might combine a lower yield with weak or negative price growth, while a central and optimistic case can show the range created by different assumptions. Final shares tells you how much ownership the DRIP accumulated. Dividends reinvested is the cumulative cash amount used for those purchases, not the ending market value of the purchased shares. Final value includes both original and reinvested shares at the projected final price. Total return compares that value with the original holding only; it does not include taxes, fees, outside contributions, withdrawals, or inflation. API requests cost $0.002, while the browser calculation uses the same deterministic logic.
What you can do with it
Compare taking cash with reinvesting
Estimate how many additional fractional shares automatic reinvestment could accumulate over a chosen holding period.
Stress-test an income holding
Combine a fixed yield with flat, positive, or negative price growth to inspect a range of simplified outcomes.
Explain long-term compounding
Show how repeated dividend purchases expand share count and allow later distributions to be earned on more shares.
FAQ
What does the calculation cost?
The calculator is free in the browser. Each API request costs $0.002.
Does the calculator allow fractional shares?
Yes. Every dividend is divided by the projected share price and the resulting fractional shares are retained at full precision.
Is dividend yield assumed to change as the share price changes?
No. The entered annual yield remains fixed throughout the projection and is applied to the current holding value in equal periodic portions.
Can I model a falling share price?
Yes. The annual price growth rate may be negative down to -99.99%, which supports severe decline scenarios without reaching a zero or negative price.
Are taxes and reinvestment fees included?
No. The projection assumes the entire dividend is reinvested immediately with no tax, withholding, fee, spread, or purchase delay.
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/finance/drip-reinvestment \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"initial_shares":100,"share_price":50,"annual_dividend_yield_percent":4,"annual_price_growth_percent":6,"years":10}'const res = await fetch("https://api.kit.forhosting.com/finance/drip-reinvestment", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"initial_shares": 100,
"share_price": 50,
"annual_dividend_yield_percent": 4,
"annual_price_growth_percent": 6,
"years": 10
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/finance/drip-reinvestment",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"initial_shares": 100,
"share_price": 50,
"annual_dividend_yield_percent": 4,
"annual_price_growth_percent": 6,
"years": 10
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/finance/drip-reinvestment", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"initial_shares":100,"share_price":50,"annual_dividend_yield_percent":4,"annual_price_growth_percent":6,"years":10}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"initial_shares":100,"share_price":50,"annual_dividend_yield_percent":4,"annual_price_growth_percent":6,"years":10}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/finance/drip-reinvestment", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"initial_shares": 100,
"share_price": 50,
"annual_dividend_yield_percent": 4,
"annual_price_growth_percent": 6,
"years": 10
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "finance.drip_reinvestment",
"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_years | 100 |
max_dividend_payments_per_year | 365 |
max_projection_periods | 36500 |
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. |