ForHosting KIT · Finance & money

Black-Scholes calculator

A one-year call with the underlying and the strike both at 100, a 5% interest rate and 20% volatility is worth just over 10 under Black-Scholes. Enter your five market inputs to price any European call or put. Free in your browser.

Free
Runs in your browser
No sign-up
Your data stays on your device

Run — free How it works & API

Use it from WebAPIEmailTelegramApp soon

Worked example

If you enter

Spot: 100
Strike: 100
Time to expiry: 1
Interest rate: 0.05
Volatility: 0.2
Option type: Call

You get

D1: 0.35
D2: 0.15
N d1: 0.636830586
N d2: 0.5596177096

The Black-Scholes formula is the closed-form price of a European call or put on a non-dividend-paying underlying. Given today's spot, the strike, time to expiry in years, a continuously compounded risk-free rate, and a constant volatility, it returns a single theoretical premium that every textbook, desk worksheet, and interview question still treats as the reference. Zero time collapses to intrinsic value; zero volatility collapses to the discounted deterministic payoff.

How the Black-Scholes European call and put are computed

Black-Scholes prices a European option that can be exercised only at expiry on an underlying that pays no dividend. The five market inputs are today's spot S, strike K, time to expiry T in years, a continuously compounded risk-free rate r entered as a decimal (zero point zero five means five percent, not five), and a constant annualized volatility σ also entered as a decimal (zero point two means twenty percent).

From those the calculator forms d1 equals the natural log of S over K plus r plus half of σ squared, all times T, divided by σ times the square root of T, and d2 equals d1 minus σ times the square root of T. N is the standard normal cumulative distribution, evaluated with a fixed Abramowitz and Stegun error-function approximation so the same inputs always produce the same digits. A call is S times N of d1 minus K times e to the minus rT times N of d2.

A put is K times e to the minus rT times N of minus d2 minus S times N of minus d1. Those two prices obey put-call parity: call minus put equals S minus the discounted strike. When T is exactly zero the formula is undefined (division by the square root of T) and the price is the intrinsic value, max of S minus K and zero for a call, max of K minus S and zero for a put.

When volatility is exactly zero the underlying is deterministic and the price is the discounted certain payoff, max of plus or minus S minus K e to the minus rT. Both of those limits are computed in closed form instead of sending d1 to plus or minus infinity. Spot and strike must be strictly positive because the model takes the log of their ratio.

What you can do with it

Homework and interview checks

Verify a hand-worked European call or put from S, K, T, r, and σ against a deterministic Black-Scholes premium and the usual d1, d2 terms.

LMS and worksheet grading

Mark option-pricing items with an oracle that rejects negative volatility or tenor and never invents a price when the model is undefined.

FAQ

What happens if volatility or time to expiry is negative?

Negative volatility and a negative tenor are not defined in Black-Scholes; those requests are not billed. Zero is allowed for both.

Are the risk-free rate and volatility percents or decimals?

Decimals. Enter 0.05 for a 5 percent rate and 0.2 for 20 percent volatility. Entering 5 or 20 would be treated as 500 percent and 2000 percent, not as market quotes.

What does the calculator return besides the option price?

When T and σ are both positive it also reports d1, d2, N(d1), and N(d2).

Can I use Black-Scholes for American options or stocks that pay dividends?

Not with this model. Black-Scholes prices a European option, which can only be exercised at expiry, on an underlying that pays no dividend. For early exercise or dividend payments you need a different pricing method.

What price do I get for an option expiring today or with zero volatility?

With zero time left, the price is simply the intrinsic value: how far the option is in the money, or zero. With zero volatility the outcome is certain, so the price is that certain payoff discounted at the interest rate.

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

POSThttps://api.kit.forhosting.com/fin/black-scholes

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/black-scholes \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d '{"spot":100,"strike":100,"time_to_expiry":1,"rate":0.05,"volatility":0.2,"option_type":"call"}'

const res = await fetch("https://api.kit.forhosting.com/fin/black-scholes", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.KIT_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "spot": 100,
    "strike": 100,
    "time_to_expiry": 1,
    "rate": 0.05,
    "volatility": 0.2,
    "option_type": "call"
  })
});
const { task_id } = await res.json();

import os, requests

res = requests.post(
    "https://api.kit.forhosting.com/fin/black-scholes",
    headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
    json={
    "spot": 100,
    "strike": 100,
    "time_to_expiry": 1,
    "rate": 0.05,
    "volatility": 0.2,
    "option_type": "call"
},
)
task_id = res.json()["task_id"]

<?php
$res = file_get_contents("https://api.kit.forhosting.com/fin/black-scholes", false, stream_context_create([
  "http" => [
    "method"  => "POST",
    "header"  => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
    "content" => '{"spot":100,"strike":100,"time_to_expiry":1,"rate":0.05,"volatility":0.2,"option_type":"call"}',
  ],
]));
$task = json_decode($res, true);

body := bytes.NewBufferString(`{"spot":100,"strike":100,"time_to_expiry":1,"rate":0.05,"volatility":0.2,"option_type":"call"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/fin/black-scholes", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)

Example request

{
  "spot": 100,
  "strike": 100,
  "time_to_expiry": 1,
  "rate": 0.05,
  "volatility": 0.2,
  "option_type": "call"
}

Example response

{
  "task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
  "type": "fin.black_scholes",
  "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

Per request$0.002

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

This capability implements that identity as a pure parse task: it builds d1 and d2, evaluates the standard normal cumulative distribution, and returns the discounted risk-neutral expectation as option_price. Negative volatility or a negative time to expiry is rejected with invalid_input and is not billed, because those inputs are not defined in the model.

Input contract, response shape, and error behaviour

Zero is allowed for both: expiry today is intrinsic, and a flat path is the discounted deterministic payoff. Rate may be zero or negative, matching modern money-market quotes. POST a JSON body with six required fields. spot is the current underlying price S; aliases S, spot_price, and price map to the same field. strike is K; aliases K and strike_price. time_to_expiry is T in years, so one is twelve months and zero point two five is a quarterly option; aliases T, time, and years. rate is the continuously compounded risk-free rate as a decimal; aliases r, risk_free_rate, and interest_rate. volatility is σ as a decimal; aliases sigma and vol. option_type is the closed enum call or put; aliases type, option, and kind. 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. A negative volatility or a negative time_to_expiry fails with a message that the field must not be negative — those failures are not billed. On success the body echoes the six inputs, reports discount_factor e to the minus rT, intrinsic, and option_price rounded to eight decimals. When T and σ are both strictly positive it also reports d1, d2, n_d1, and n_d2 so a worksheet can show the usual intermediate terms; those four keys are omitted, never null, when the closed-form limits apply. Example: S and K of one hundred, T of one year, r of zero point zero five, σ of zero point two, option_type call, yields a textbook at-the-money European call near ten point four five, with the matching put following from put-call parity.

Where a Black-Scholes option calculator earns its keep

Students and interview candidates use a Black-Scholes calculator to check a hand-worked European call or put against a deterministic oracle instead of a spreadsheet that silently treats twenty as twenty percent or as a decimal two thousand percent. Desk tools and research notebooks need a tiny parse contract for a vanilla European mark when they do not want to pull a full analytics library for five numbers. Failed validation does not consume balance. Tutoring platforms and LMS plugins post spot, strike, time_to_expiry, rate, volatility, and option_type, then pin option_price and the d1 line so a grader can mark both the final premium and the intermediate terms. Keep rate and volatility as decimals, keep time_to_expiry and volatility non-negative, pin the rounded option_price in tests, and you get a reproducible European premium for homework, desk checks, and edge workers without standing up a pricing engine of your own.

Integration use cases

Desk marks and CI fixtures

Pin a vanilla European premium in notebooks and regression tests without importing a full derivatives analytics library.

Technical questions

How is a European call or put priced with Black-Scholes?

Send positive spot and strike, non-negative time_to_expiry in years, rate and volatility as decimals, and option_type call or put. The API returns option_price = S·N(d1) − K·e^(−rT)·N(d2) for a call, or the put formula with N(−d1) and N(−d2).

What does the Black-Scholes calculator cost?

The browser tool is free. API requests use prepaid KIT balance at $0.002 per successful call; invalid input is not billed.

Read the full KIT documentation →

Run — free