Combined magnitude of two stars
A magnitude 1 star and a magnitude 2 star seen as one point shine at magnitude 0.6361488422, brighter than either alone. Enter the two apparent magnitudes and see each star's relative light, their sum and the combined result. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Magnitude 1
- 1
- Magnitude 2
- 2
- Flux 1
- 0.3981071706
- Flux 2
- 0.1584893192
- Flux total
- 0.5565964898
- Combined magnitude
- 0.6361488422
When two stars lie so close on the sky that a photometer or the eye records them as one source, the measured brightness is not the arithmetic mean of their magnitudes. Apparent magnitude is a logarithmic scale: flux ratios map to magnitude differences through the Pogson factor of 2.5. Adding the light of two stars therefore means converting each magnitude to a relative flux, summing those fluxes, and converting the total flux back to a single combined magnitude. This combined magnitude of two stars calculator accepts two finite apparent magnitudes, applies that exact identity, and returns the total magnitude together with intermediate relative fluxes so students, observers, and pipelines can verify every step.
Why magnitudes do not add and how flux summation works
The modern stellar magnitude system is rooted in Pogson’s nineteenth-century definition that five magnitudes correspond to a factor of one hundred in flux. That forces a relative flux of ten to the power of minus zero point four times magnitude: each step of one magnitude multiplies or divides the light by about two point five one two. Because the scale is logarithmic, you cannot average two magnitudes and call the result the combined brightness of a close double or an unresolved pair.
If one star is much brighter than the other, the fainter companion barely moves the total; if both are equal, the pair is brighter than either alone by roughly zero point seven five magnitudes, which is two point five times the base-ten log of two.
The correct procedure is always the same: convert each apparent magnitude m to a relative flux F equals ten to the power of minus zero point four m, form F total equals F one plus F two, then recover m combined equals minus two point five times log base ten of F total. That formula is exact for monochromatic or bolometric fluxes under the same zero point and bandpass; it does not require distance, luminosity, or extinction unless you already folded those effects into the input apparent magnitudes.
What you enter and what you get back
An optional precision integer from zero to fifteen (default ten) controls how many decimal places appear on every numeric field in the response. Extremely large absolute magnitudes outside the supported ceiling are rejected so that power and logarithm stay finite. Example: two equal first-magnitude stars yield a combined magnitude near zero point two five because their fluxes double and two point five log ten of two is about zero point seven five.
Pair this response with your own plotting or catalog code if you need spectral types or coordinates; this capability only combines two scalar magnitudes and never contacts a network.
Where a two-star combined magnitude tool earns its keep
Visual double-star observers and photometry lab courses need a fast check that the unresolved pair magnitude matches the catalog sum of components before they trust a reduction pipeline. Variable-star programs that treat a constant companion as a comparison star still need to know how much light the companion would add if the aperture blends both objects. Content generators for astronomy homework can mark student answers against a deterministic oracle instead of hand-built spreadsheets that silently average magnitudes.
Failed validation does not consume balance.
What you can do with it
Visual doubles and blended photometry
Estimate the total apparent magnitude of an unresolved or close pair when component magnitudes are known from catalogs or differential photometry.
Classroom and lab checks
Let students submit two magnitudes and verify the flux-sum result against hand calculation of 10^(−0.4 m) without spreadsheet sign errors.
FAQ
Can I just average the two magnitudes?
No. Magnitude is logarithmic. Averaging m1 and m2 does not equal the brightness of the combined light; only summing fluxes and converting back is correct.
What if one star is much fainter than the other?
The combined magnitude still moves slightly toward the brighter star. The fainter flux contributes less, so the total is only a little brighter than the brighter component alone.
What is the combined magnitude of a magnitude 1 and a magnitude 2 star?
Magnitude 0.6361488422, shown with ten decimals by default. Each magnitude is turned into an amount of relative light, the two amounts are added, and the total is turned back into a magnitude, so the pair is brighter than either star alone.
How much brighter are two equal stars together?
About 0.75 magnitudes brighter than one of them, because their light doubles and 2.5 times the base-ten logarithm of two is close to 0.75. Two equal first-magnitude stars therefore combine to roughly magnitude 0.25.
Do I need the distance to each star?
No. The calculation only needs the two apparent magnitudes, measured with the same zero point and in the same band. Distance, luminosity and extinction matter only if you have not already folded them into those magnitudes.
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/astro/combined-magnitude \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"magnitude_1":1,"magnitude_2":2}'const res = await fetch("https://api.kit.forhosting.com/astro/combined-magnitude", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"magnitude_1": 1,
"magnitude_2": 2
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/astro/combined-magnitude",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"magnitude_1": 1,
"magnitude_2": 2
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/astro/combined-magnitude", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"magnitude_1":1,"magnitude_2":2}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"magnitude_1":1,"magnitude_2":2}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/astro/combined-magnitude", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"magnitude_1": 1,
"magnitude_2": 2
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "astro.combined_magnitude",
"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 free browser path and the paid API share the same pure arithmetic module, so homework checks and automation scripts never disagree on the same pair of inputs.
Why magnitudes do not add and how flux summation works
This endpoint implements only that flux-sum step so the contract stays small, deterministic, and free of ephemeris or catalog lookups.
Input contract, response fields, and validation errors
POST a JSON body with two required finite numbers: magnitude_1 and magnitude_2, the apparent magnitudes of the two stars on the usual astronomical scale where smaller numbers are brighter. Optional aliases include m1, mag1, mag_a, a for the first star and m2, mag2, mag_b, b for the second. Missing fields, empty strings, non-numeric text, Infinity, and NaN fail with invalid_input and are not billed. On success the body echoes both magnitudes, reports relative flux_1 and flux_2 from the Pogson conversion, flux_total as their sum, combined_magnitude as the final result, magnitude_difference as the absolute gap between the two inputs, the precision used, a short method tag, and a formula string restating the identity.
Where a two-star combined magnitude tool earns its keep
Keep requests small, pin the rounded combined_magnitude in tests, and you get reproducible totals for lab sheets, LMS plugins, and edge workers without standing up a full astronomy library of your own.
Integration use cases
Pipeline and CMS widgets
Embed the free browser tool or call the API from reduction scripts so blended-aperture predictions stay byte-identical across environments.
Technical questions
How is the combined magnitude of two stars calculated?
Convert each magnitude to relative flux with F = 10^(−0.4 m), add the fluxes, then convert back with m = −2.5 log10(F_total). That is the Pogson-scale flux sum used by this calculator.
What inputs cause invalid_input?
Missing magnitude_1 or magnitude_2, non-numeric values, Infinity, NaN, or magnitudes outside the supported absolute range. Those failures are not billed.
What does the combined magnitude calculator cost?
The browser tool is free. API requests use prepaid KIT balance at $0.002 per successful call; invalid input is not billed.