e^x calculator
e squared is 7.38905609893065: type one exponent and get e raised to it, where e ≈ 2.718281828459045. Use it for continuous compounding, radioactive decay or a capacitor discharging. The result is always positive. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- X
- 2
- Exp
- 7.3890560989
The exponential function is the backbone of continuous growth and decay: compound interest, radioactive decay, population models, charging capacitors, and the normal distribution all reduce to e raised to some power. You send one number, you get one number back: no bases to configure, no rounding modes to choose, and no surprises. Input that is not a finite number — text, booleans, NaN, or infinity — is rejected with a clear error instead of silently producing NaN.
What e to the power of x actually means
Euler's number e ≈ 2.718281828459045 is the unique base for which the exponential function equals its own derivative, which is why it appears everywhere a quantity changes at a rate proportional to itself. Raising e to a power x asks the question: if something grows continuously at 100% per unit of time, by what factor does it multiply after x units? Negative exponents never produce negative results, only fractions approaching zero.
Where the exponential shows up in practice
Finance reaches for e^x whenever interest compounds continuously: a balance at annual rate r after t years multiplies by e^(rt), so a quick call answers growth questions without building a spreadsheet. Physics and chemistry use the same function in reverse for decay — the remaining fraction of a radioactive isotope or a discharging capacitor is e^(-t/τ), where τ is the time constant.
Electronics engineers computing the step response of an RC circuit, biologists fitting exponential population growth, and epidemiologists estimating doubling times all reduce their formulas to e raised to a single number.
What you can do with it
Compute continuous compound growth
Evaluate e^(r·t) to find the growth factor of an investment, population, or viral metric compounding continuously at rate r over time t.
Model exponential decay
Feed a negative exponent like -t/τ to get the remaining fraction of a radioactive sample, a discharging capacitor, or a cooling object.
Evaluate sigmoid and softmax inputs
Use e^x directly when debugging logistic functions, softmax denominators, or Gaussian kernels outside your usual ML framework.
FAQ
What does it cost?
The same computation runs free in your browser on this page.
Can the result be negative or zero?
No. e^x is strictly positive for every real x; negative exponents yield fractions between 0 and 1, approaching zero but never reaching it.
How accurate is the result?
It uses the platform's native double-precision exponential, correctly rounded to the last bit, with no extra rounding applied.
Is the computation deterministic?
Yes. There is no randomness, no clock, and no network access; identical input always yields the identical floating-point result.
What is the largest exponent I can use for e^x?
About 709.78. Beyond that point the result is too large to be represented, so instead of showing a misleading infinity you get a clear message that the value is out of range.
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/math/e-power-x \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"x":2}'const res = await fetch("https://api.kit.forhosting.com/math/e-power-x", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"x": 2
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/math/e-power-x",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"x": 2
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/math/e-power-x", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"x":2}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"x":2}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/math/e-power-x", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"x": 2
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "math.e_power_x",
"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
The e power x API computes the natural exponential e^x for any finite real number and returns the exact value in a single call.
What e to the power of x actually means
At x = 0 the answer is exactly 1; at x = 1 it is e itself; at x = -1 it is the reciprocal 1/e ≈ 0.368. The function is strictly increasing, always positive, and symmetric in the sense that e^-x = 1/e^x. When you feed a value into this endpoint you get back the raw exponential as a floating-point number, with no scaling, no unit conversion, and no rounding applied beyond the platform's native double precision.
How the value is computed and validated
The computation itself uses the platform's correctly rounded native exponential, the same primitive your browser's JavaScript engine and most scientific libraries rely on. One boundary matters: the largest exponent whose exponential still fits in a double is about 709.78. Input validation is deliberately strict: the endpoint accepts a single field x, which may be a JSON number or a numeric string, and rejects everything else — booleans, arrays, objects, empty strings, NaN, and the infinities — with an invalid_input error, so you never pay for a garbage call. Beyond that, e^x genuinely has no finite floating-point representation, so instead of returning the misleading value Infinity, the endpoint reports a clear out-of-range error. The result is fully deterministic: identical input always yields an identical output, with no randomness, no clock, and no network access, which is why the free browser version and the paid API version agree bit for bit.
Where the exponential shows up in practice
In probability, the normal curve is e^(-x²/2) up to a constant, and the logistic sigmoid is built from e^x, so machine-learning practitioners evaluating scores by hand hit this endpoint constantly. Whatever your domain, this endpoint evaluates it in one request for $0.002 per call, and the same computation runs free in the browser on this page.
Technical questions
What input does it accept?
A single field x holding a finite number, either as a JSON number or a numeric string. Anything else is rejected with an invalid_input error.
What happens for very large exponents?
Above roughly x = 709.78 the true value of e^x no longer fits in a double, so the endpoint returns a clear out-of-range error instead of Infinity.