Call put option calculator
A call with a strike of 100, bought for a premium of 4, pays 10 at expiry if the underlying closes at 110: a net profit of 6, with breakeven at 104. Enter call or put, strike, expiry price and premium to check any position. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Option type
- Call
- Strike
- 100
- Underlying
- 110
- Premium
- 4
- Payoff
- 10
- Net profit
- 6
- Breakeven
- 104
- Moneyness
- in_the_money
A listed call or put that has reached expiration is no longer priced with implied volatility or leftover time value. The remaining cash is the intrinsic payoff, and the long holder's result is that payoff minus the premium paid to open the position. This call put option calculator takes the option type, the strike, the underlying price observed at expiry, and the premium, then returns both the expiration payoff and the net profit on a one-unit long contract. A call pays the positive part of the underlying minus the strike; a put pays the positive part of the strike minus the underlying.
What expiration payoff and net profit mean for a call or put
At expiration a vanilla option has no remaining time value, so its mark is the intrinsic payoff and nothing else. For a long put the payoff is the greater of the strike minus the underlying and zero: if the underlying finishes below the strike the holder can sell at the strike against a cheaper market; otherwise the put expires worthless. Net profit on a long position of one unit is that payoff minus the premium paid when the option was purchased.
The premium is a sunk cost at expiry, so an in-the-money option can still lose money when the intrinsic value does not cover what was paid. The long-call breakeven is the strike plus the premium; the long-put breakeven is the strike minus the premium. Moneyness is reported separately from profit: a call is in the money when the underlying exceeds the strike, at the money when they are equal, and out of the money when the underlying is below the strike, with the inequalities reversed for a put.
What you can do with it
Homework and interview checks
Verify a hand-drawn long call or put expiration diagram from strike, underlying at expiry, and premium against a deterministic payoff and net profit.
LMS and worksheet grading
Mark option-payoff items with an oracle that rejects a type other than call or put and never invents a profit when the position expires worthless.
FAQ
What happens if the option type is not call or put?
Only the two vanilla expiration payoffs are in scope, so a future, straddle, or any other label is rejected and is not billed.
Does an in-the-money option always show a profit?
No. Moneyness compares the underlying with the strike only. Net profit subtracts the premium, so a call that finishes two points in the money after a four-point premium is still a two-point loss.
What breakeven does the calculator report?
The long-call breakeven is strike plus premium. The long-put breakeven is strike minus premium. Both assume a one-unit long position with no multiplier and no discounting.
How is a put option's payoff worked out at expiry?
A put pays the strike minus the underlying price when the underlying finishes below the strike, and nothing otherwise. If the underlying ends at zero, the payoff equals the full strike. Your net profit is that payoff minus the premium paid.
Does the result include the contract multiplier or any time value?
No. The result is for one unit of a long option at expiration, when no time value is left. Multiply by your contract size yourself, and use a pricing model if the option still has time to run.
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/call-put-option \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"option_type":"call","strike":100,"underlying":110,"premium":4}'const res = await fetch("https://api.kit.forhosting.com/fin/call-put-option", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"option_type": "call",
"strike": 100,
"underlying": 110,
"premium": 4
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/fin/call-put-option",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"option_type": "call",
"strike": 100,
"underlying": 110,
"premium": 4
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/fin/call-put-option", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"option_type":"call","strike":100,"underlying":110,"premium":4}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"option_type":"call","strike":100,"underlying":110,"premium":4}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/fin/call-put-option", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"option_type": "call",
"strike": 100,
"underlying": 110,
"premium": 4
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "fin.call_put_option",
"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 the type is not call or put the task fails with invalid_input and is not billed.
What expiration payoff and net profit mean for a call or put
For a long call that payoff is the greater of the underlying price minus the strike and zero: if the underlying finishes above the strike the holder can buy at the strike and sell at the market, pocketing the difference; if it finishes at or below the strike the call expires worthless. This endpoint does not discount cash flows, does not apply a contract multiplier, and does not price remaining life; it answers the expiry worksheet question only, with a deterministic net profit you can pin in tests.
Input contract, response shape, and error behaviour
POST a JSON body with four required fields. option_type is the closed enum call or put; aliases type, option, and kind map to the same field. Any other string, including future, straddle, or an empty value, fails with invalid_input naming option_type, because this calculator is only the two vanilla payoffs. strike is the exercise price K and must be a finite number strictly greater than zero; aliases K and strike_price. underlying is the observed price of the underlier at expiration and must be a finite number greater than or equal to zero, so a put that finishes with the underlier at zero still has a well-defined payoff equal to the strike; aliases S, spot, price, underlying_price, and expiry_price. premium is the price paid per unit to buy the option and must be a finite number greater than or equal to zero; aliases price_paid, cost, and option_premium. Each numeric field may arrive as a JSON number or a numeric string. Missing fields, empty strings, and non-finite values fail with invalid_input naming the field, and those failures are not billed. On success the body echoes the four inputs, reports payoff and net_profit, the long-position breakeven, moneyness as in_the_money, at_the_money, or out_of_the_money, and outcome as profit, loss, or breakeven, plus a short formula string. Example: a call with strike one hundred, underlying one hundred ten, and premium four yields payoff ten and net profit six, because the call finishes ten points in the money and four of those points cover the premium. Pair the response with your own payoff diagram if you need a sketch; this endpoint returns numbers only.
Where a call put option payoff calculator earns its keep
Desk tools and research notebooks need a tiny parse contract for the expiry line of a long vanilla when they do not want to pull a full analytics library for four numbers. Failed validation does not consume balance. Students and interview candidates use a call put option calculator to check a hand-drawn expiration diagram against a deterministic oracle instead of a spreadsheet that silently swaps the call and put signs. Tutoring platforms and LMS plugins post option_type, strike, underlying, and premium, then pin payoff and net_profit so a grader can mark both the intrinsic value and the profit after premium. Keep the type in the closed enum, keep strike strictly positive, keep the underlying and the premium non-negative, pin the rounded net_profit in tests, and you get a reproducible expiration result for homework, desk checks, and edge workers without standing up a derivatives engine of your own.
Integration use cases
Desk notes and CI fixtures
Pin the expiry line of a long vanilla in notebooks and tests without importing a full derivatives library for four numbers.
Technical questions
How do I compute the expiration profit of a call or put?
Send option_type (call or put), strike, the underlying price at expiry, and the premium paid. The API returns payoff max(S−K, 0) for a call or max(K−S, 0) for a put, and net_profit equal to payoff minus premium.
What does the call put option calculator cost?
The browser tool is free. API requests use prepaid KIT balance at $0.002 per successful call; invalid input is not billed.