How to run excel goal seek without excel — binary search solver in your browser
- Step 1Identify the formula cell and the input cell — Open your model and note the cell whose result you want to control (the target, e.g.
D5) and the cell you are willing to change to get there (the input, e.g.B2). The target must contain a formula; the input is normally a static number. Confirm the target's formula uses only supported functions (see the support matrix below) before you upload. - Step 2Upload the .xlsx file — Drop your workbook onto the tool. Only
.xlsxis accepted (not.csvor.xls). Parsing runs in your browser via SheetJS, so the model's numbers stay local. Goal Seek is gated to the Developer tier — free, Pro, and Pro-media accounts will be blocked with a tier message. - Step 3Enter the target cell and target value — Type the target cell reference into
targetCell(e.g.D5) and the number you want it to equal intotargetValue. The default target value is0, which is exactly right for break-even and root-finding; change it for any other goal. - Step 4Enter the input cell — Type the cell to vary into
inputCell(e.g.B2). The solver brackets its search around this cell's current saved value, so a sensible starting number (not blank, not wildly off) helps it converge faster. - Step 5Set the sheet name if needed — If your target and input cells live on a sheet other than the first, type its name into
sheetName. Leave it blank to default to the first sheet in the workbook. Sheet prefixes inside the formula itself (Sheet2!A1) are read as same-sheet references during evaluation. - Step 6Run and read the report — Run the solver. The report shows
✓ convergedor⚠ best approximation, the input value to 6 decimals, the resulting output, the target, the residual, and the iteration count. The result is a text report you can copy or download — it does not write the value back into a new workbook, so type the converged input into your own model manually.
The four Goal Seek options
Every control the tool exposes, with type, default, and meaning. There are no presets, no tolerance slider, and no algorithm choice — these four fields are the entire contract.
| Option | Type | Default | What it does |
|---|---|---|---|
targetCell | string (cell ref) | — (required) | Cell holding the formula whose output you want to control, e.g. D5. Must contain a formula, not a static value. |
targetValue | number | 0 | The number the target cell should equal. 0 is the default and is ideal for break-even / root-finding. |
inputCell | string (cell ref) | — (required) | Cell to vary during the search, e.g. B2. Normally a static number; its current value seeds the search bracket. |
sheetName | string | first sheet | Sheet containing the target and input cells. Defaults to the workbook's first sheet when blank. |
Supported formula vocabulary in the target cell
The target formula is parsed by a built-in arithmetic evaluator. Anything outside this list returns NaN, which stops the search. References resolve to the workbook's cached cell values; only the input cell is varied.
| Category | Supported | Not supported (returns NaN → search fails) |
|---|---|---|
| Operators | + - * / ^ % and comparisons = <> < <= > >= | & text concatenation (tokenized but not evaluated) |
| Math functions | SUM, MIN, MAX, AVERAGE, ABS, SQRT, INT, ROUND, MOD, POWER | PMT, NPV, IRR, EXP, LN, LOG, RAND, and most others |
| Logic functions | IF, AND, OR, NOT, IFERROR (plus TRUE/FALSE as 1/0) | IFS, SWITCH, CHOOSE |
| Lookups / ranges | single cell refs only (B2, $C$4, Sheet2!A1) | range syntax A1:A10, VLOOKUP, XLOOKUP, INDEX, MATCH |
| Text | — | CONCAT, LEFT, MID, TEXT, and all text functions |
Solver behaviour and limits
How the bisection search runs and where the boundaries are. The output is a text report, not a re-saved workbook.
| Aspect | Value / behaviour |
|---|---|
| Algorithm | Bisection (binary search) on the input value |
| Max iterations | 1,000 |
| Convergence threshold | residual < 1e-8 (absolute difference from target) |
| Initial bracket | ≈ current input ± (10 × |current input| + 1,000) |
| Cells used | all non-input cells use cached saved values; only the input cell varies; only the target formula is recomputed |
| Accepted input | .xlsx only |
| Output | text report (converged?/input/output/residual/iterations) — no filled workbook is produced |
| Tier / size | Developer tier · up to 500 MB · unlimited rows |
Cookbook
Worked single-variable solves you can reproduce. Each shows the target formula, the inputs you'd type, and the report the solver returns.
Root-finding: solve a formula to zero
The canonical use of the default target value. Cell D5 holds a profit formula; you want the units (B2) that drive profit to exactly 0.
Sheet1: B2 = 0 (input — units, will be varied) C2 = 25 (price per unit) C3 = 10 (variable cost per unit) C4 = 4500 (fixed cost) D5 = (B2*C2) - (B2*C3) - C4 (profit formula) Options: targetCell = D5 targetValue = 0 inputCell = B2 Report: ✓ Goal Seek converged after 47 iteration(s). Input cell: B2 = 300.000000 Output cell: D5 = 0.000000 Target value: 0 Residual: 0.00e+0
Hit a non-zero target output
Change targetValue to solve for any output, not just zero. Here you want revenue (D2) to equal exactly 50,000 by varying the unit count.
Sheet1: B2 = 100 (input — units sold) C2 = 25 (price) D2 = B2*C2 (revenue) Options: targetCell = D2 targetValue = 50000 inputCell = B2 Report: ✓ Goal Seek converged after 31 iteration(s). Input cell: B2 = 2000.000000 Output cell: D2 = 50000.000000 Target value: 50000 Residual: 0.00e+0
Solve a power/exponent relationship
POWER and ^ are supported, so growth-style formulas solve cleanly. Find the annual growth rate (B2) that turns 1,000 into 1,610.51 over 5 periods.
Sheet1: B2 = 0.05 (input — growth rate) C2 = 1000 (starting value) C3 = 5 (periods) D2 = C2 * POWER(1+B2, C3) Options: targetCell = D2 targetValue = 1610.51 inputCell = B2 Report: ✓ Goal Seek converged after 52 iteration(s). Input cell: B2 = 0.100000 Output cell: D2 = 1610.510000 Target value: 1610.51
Target the value on a named sheet
When the model lives on a second tab, set sheetName so the solver reads the right cells. The references B2/D5 are resolved within that sheet.
Workbook tabs: [Summary] [Model] Model sheet: B2 = 0 (input) D5 = B2*120 - 9000 Options: targetCell = D5 targetValue = 0 inputCell = B2 sheetName = Model Report: ✓ Goal Seek converged after 44 iteration(s). Input cell: B2 = 75.000000 Output cell: D5 = 0.000000
A run that does not converge
If the target value is unreachable for the formula (no real input produces it), the solver returns the closest approximation rather than a false answer.
Sheet1: B2 = 1 (input) D2 = B2*B2 + 10 (always >= 10) Options: targetCell = D2 targetValue = 5 (impossible — min is 10) inputCell = B2 Report: ⚠ Goal Seek did not fully converge (best residual: 5.00e+0). Best found: Input cell: B2 = 0.000000 Output cell: D2 = 10.000000 Target value: 5
Edge cases and what actually happens
Target cell holds a static value, not a formula
RejectedGoal Seek needs a formula to vary the input against. If the target cell contains a typed number instead of a formula, the report returns Target cell D5 must contain a formula for Goal Seek. It currently holds a static value. Point the tool at the actual formula cell, or rebuild the calculation as a formula first.
Target or input cell reference doesn't exist
Invalid cellIf targetCell or inputCell names an empty or non-existent address on the chosen sheet, the report returns Cell <addr> not found in sheet "<name>". Check for typos (D5 vs 5D), confirm you set the right sheetName, and make sure the input cell actually holds a value.
Formula uses an unsupported function
NaN / search failsFunctions outside the supported list (PMT, NPV, VLOOKUP, EXP, etc.) evaluate to NaN, which breaks the bisection — the run stops early and won't converge. Rewrite the target formula using supported arithmetic and functions, or use the formula explainer to see what the formula actually contains.
Formula uses a range like SUM(A1:A10)
NaN / search failsThe evaluator resolves single cell references only — colon range syntax isn't parsed, so SUM(A1:A10) returns NaN. Expand the range into explicit comma-separated cells, e.g. SUM(A1,A2,A3,...), or precompute the sum into one cell and reference that.
Other formula cells are stale
Cached values usedEvery cell except the input is read at its last-saved cached value, and only the target formula is recomputed. If the target references another formula cell, that dependency uses its cached result and is NOT recalculated as the input changes — so multi-step dependency chains can solve against stale intermediate values. Save the workbook with fresh calculations first.
Multi-variable problem
Out of scopeGoal Seek varies exactly one input cell. Problems with several decision variables or constraints (allocation, optimization) are Solver's job, not Goal Seek's. This tool implements the single-variable case only — see the Goal Seek vs Solver guide below for the distinction.
Target is reachable at multiple inputs
One root returnedFor non-monotonic formulas (e.g. quadratics) more than one input can hit the target. Bisection returns whichever root falls inside the auto-bracket around the input cell's starting value. Seed inputCell near the root you want to find the right one.
Division by zero inside the formula
NaN / search failsThe evaluator returns NaN when a / operand is zero, so a formula that divides by the input (or by a cell that's zero at some search point) can break the search. Restructure the formula to avoid dividing by the varied input, or wrap the risky term in IFERROR.
Result isn't written back to the file
By designThe output is a text report, not a re-saved workbook with the answer filled in. Read the converged input from the report and type it into your own model. Use formula-to-value afterward if you want to freeze the recalculated results into static cells.
Frequently asked questions
Does this need Microsoft Excel installed?
No. The tool reads the .xlsx with SheetJS in your browser and runs its own bisection solver — there's no Excel, no add-in, and no server upload. That's the whole point: Excel's built-in Goal Seek only runs in the desktop app, and this brings the single-variable case anywhere you have a browser.
How is this different from Excel's built-in Goal Seek?
Excel uses a Newton-style iterative method and writes the answer straight back into the input cell. This tool uses deterministic bisection (binary search) over up to 1,000 iterations and returns a text report instead of editing the file. The trade-off: bisection is reproducible and won't overshoot, but it only varies one cell and recomputes only the target formula.
Why does it say the target cell must contain a formula?
Goal Seek works by changing the input and recomputing the target formula to see how close it gets. If the target is a typed number, there's nothing to recompute — varying the input would never change it. Point the tool at the formula cell whose result depends on your input.
Which functions can the target formula use?
SUM, MIN, MAX, AVERAGE, ABS, SQRT, INT, ROUND, MOD, POWER, IF, AND, OR, NOT, and IFERROR, plus all arithmetic operators (+ - * / ^ %) and comparisons. TRUE/FALSE read as 1/0. Anything else — PMT, NPV, VLOOKUP, text functions, range syntax — returns NaN and stops the search.
Can the formula reference cells on other sheets?
References with a sheet prefix (Sheet2!A1) are accepted, but the prefix is dropped and the address is looked up on the sheet you selected. For reliable results keep the target, input, and all referenced cells on the one sheet named in sheetName.
What does the residual mean?
The residual is the absolute difference between the formula's output at the best-found input and your target value. A residual below 1e-8 counts as converged; anything larger means the solver got as close as it could but couldn't hit the target exactly within 1,000 iterations.
Why didn't my run converge?
Common causes: the target value is unreachable for the formula (e.g. asking for 5 when the formula's minimum is 10), an unsupported function returned NaN, a range or lookup couldn't be parsed, or the root lies outside the auto-bracket. The report shows the best approximation and residual so you can diagnose which it is.
Does it write the answer back into my spreadsheet?
No — it returns a text report you can copy or download. Read the converged input value from the report and type it into your model. This is deliberate: the tool never re-saves your file, which keeps the original untouched.
What's the iteration limit and can I raise it?
The cap is 1,000 iterations, fixed. Bisection roughly halves the error each step, so 1,000 iterations is far more than needed for any value that's actually reachable — if you're hitting the cap, the issue is almost always an unreachable target or an unsupported formula, not too few iterations.
Are stale cached values a problem?
They can be. Every cell except the input is read at its last-saved value, and only the target formula recomputes. If the target depends on another formula cell, that intermediate value won't update as the input changes. Open and re-save the workbook so all cached values are current before uploading.
What tier do I need?
Goal Seek is a Developer-tier feature. Developer accounts get up to 500 MB files and unlimited rows. Free (5 MB / 10,000 rows), Pro (50 MB / 100,000 rows), and Pro-media (200 MB / 500,000 rows) accounts are blocked from this tool with a tier message.
What if my formula is too complex to evaluate here?
Run the formula explainer to see exactly what the target formula contains, then either simplify it to supported arithmetic or solve the sub-expressions into single cells first. For tracing which cells feed the target, the dependency map shows the precedent chain.
Privacy first
Every JAD Excel tool runs entirely in your browser using SheetJS and ExcelJS. Your spreadsheets, formulas, and data never leave your device — verified by zero outbound network requests during processing.