ForHosting KIT · Home, food & hobbies

Star trail stacking calculator

A one-hour star trail shot as 30-second frames needs 120 exposures: enter the length of each frame and the trail time you want, and see the frame count, the full session time and the sky arc covered. Free in your browser.

  • Free
  • Runs in your browser
  • No sign-up
  • Your data stays on your device
Use it from WebAPIEmailTelegramApp soon
If you enter
Single exposure seconds
30
Desired trail seconds
3,600
You get
Interval seconds
0
Frame count
120
Total integration seconds
3,600
Total session seconds
3,600

Building long, continuous star trails on a fixed tripod almost always means stacking many shorter frames instead of holding the shutter open for an hour in one go. Long single exposures heat the sensor, fill the histogram with noise, and risk a single airplane, cloud, or bump ruining the whole night. This star trail stacking frame count calculator turns two simple numbers — the length of each sub-exposure in seconds and the continuous trail duration you want — into the minimum frame count that covers that open-shutter total, plus optional intervalometer gap time so your session wall-clock is honest. The formula is fully deterministic: frame count equals the ceiling of desired trail seconds divided by single exposure seconds. A thirty-second shutter for a one-hour trail needs one hundred twenty frames; twenty-second frames for forty-five minutes need one hundred thirty-five.

Where stack frame counts fit in field work, teaching, and software

Night-sky photographers use this count when they set an intervalometer for Milky Way arches that will later be blended into long trails, for architectural cityscapes with rotating stars above a still skyline, and for workshop demos where students must finish a stack before moonrise. Educators introduce the ceiling formula when teaching why stacking many shorter frames is preferred over one multi-hour bulb exposure, and when linking open-shutter time to approximate sky arc degrees under mean sidereal rotation.

App and tool builders call the same contract from scripts to seed deterministic test vectors for night planners, to normalise user-entered exposure and duration before showing a recommended frame count, or to satisfy programming-challenge statements that demand a stable stack size rather than a hand-waved guess. Workshop practice often needs a fast, offline source of frame counts so students can program their cameras without trusting opaque phone apps that mix integration time with wall-clock session time.

Product and education tools use the calculation when a learner types a thirty-second shutter and a two-hour goal and the UI must show one hundred twenty or two hundred forty frames plus session length with a one-second gap. Pair it with five-hundred-rule or NPF helpers when you still need the opposite problem of keeping stars as points, and document that interval gaps can produce tiny dashed trails if the delay is large relative to exposure, even when total integration is correct.

Intervalometer night plan

Convert a chosen sub-exposure and a one- or two-hour trail goal into the minimum stacked frame count and session wall-clock including gap seconds.

Teaching stacking versus single long exposures

Show students why ceiling division of trail duration by shutter length sets the stack size and how interval gaps lengthen the session.

What does the star trail stacking frame count calculator cost?

It is free in your browser on this page.

Is this the same as the 500 rule?

No. The 500 rule and NPF rule estimate maximum shutter time to keep stars as points. This tool estimates how many frames to stack when you want continuous trails.

How many frames do I need for a one-hour star trail?

With 30-second exposures you need 120 frames, because 3600 seconds divided by 30 is 120. The count is always rounded up so the trail is never short.

Does the pause between frames change how many I need?

No. The frame count only covers the time the shutter is open. The pause between frames lengthens the whole session instead: frames times exposure, plus the number of gaps times the pause.

How far do the stars turn during my stack?

The tool turns the total open-shutter time into an approximate arc of sky based on the sidereal day. One hour of exposure gives an arc of about 15 degrees around the celestial pole.

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.

POSThttps://api.kit.forhosting.com/hobby/photo-star-trail-count

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.

curl -X POST https://api.kit.forhosting.com/hobby/photo-star-trail-count \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d '{"single_exposure_seconds":30,"desired_trail_seconds":3600}'
{
  "single_exposure_seconds": 30,
  "desired_trail_seconds": 3600
}
{
  "task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
  "type": "hobby.photo_star_trail_count",
  "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.

Per request$0.002

Published price — no tokens, no invented credits. A failed task is never charged.

HTTPCodeMeaning
401unauthorizedMissing or invalid API key.
402insufficient_balanceYour balance doesn't cover the task price.
404unknown_typeThat task type doesn't exist.
429rate_limitedToo many requests. Use the webhook instead of polling.

Why stack for star trails and what the response contains

Continuous star trails record Earth's rotation as arcs across the night sky. Photographers usually prefer many medium-length frames stacked in software rather than one ultra-long exposure because each frame can be discarded if it is spoiled, dark and bias frames calibrate the set, and hot pixels are easier to manage. The core planning question is simple: if each frame is open for a fixed number of seconds, how many frames do I need so the total open-shutter time reaches the trail length I want? This calculator answers that with frame_count equal to the ceiling of desired_trail_seconds over single_exposure_seconds. It also returns total_integration_seconds, which is frame count times exposure and is always at least the desired duration because of ceiling, excess_integration_seconds for that surplus, total_session_seconds when you include optional interval_seconds between frames, and trail_arc_degrees estimated from total integration using a fixed mean sidereal day of eighty-six thousand one hundred sixty-four point zero nine zero five seconds. The method tag star_trail_stack_count and a formula string make API clients and worksheets self-describing. There is no camera database and no network path: the engine either evaluates the closed form inside the supported range or rejects the input with invalid_input. Rejected cases include missing fields, non-finite values, non-positive exposure or desired trail duration, negative intervals, and runaway combinations that would demand more than the documented maximum stacked frames. This page does not replace the five-hundred rule or the NPF rule, which estimate how long a single frame can stay open before stars streak when you want points, not trails; use those tools when you are still planning sharp stars, and use this calculator when you deliberately want continuous arcs from a stack.

How exposure, desired trail, and interval are read and stay reproducible

Interval must be non-negative; a negative gap is rejected because it would imply overlapping time travel rather than a physical delay. The preferred fields are single_exposure_seconds for each stacked shutter length and desired_trail_seconds for the continuous open-shutter total you want, but aliases such as exposure, shutter, and sub_exposure for the frame length, and trail_seconds, duration, and trail_duration for the target trail are accepted so spreadsheets, query strings, and typed forms reuse the same contract. Optional interval_seconds, with aliases interval, gap, and delay, models the gap from the end of one exposure to the start of the next, including intervalometer delay and camera readout; it defaults to zero for idealized back-to-back frames. Optional leading plus signs and scientific notation on numeric strings are allowed when they parse as finite decimals; embedded spaces and non-numeric tokens fail with a clear invalid_input message so a bad cell does not become a wrong night plan. An optional precision field, with aliases decimals and dp, chooses how many decimal places to expose for the numeric fields, defaulting to ten and capped at fifteen so JSON goldens stay stable. Pair the free browser run on this page with the priced API when you need the identical mathematical result inside an automated pipeline.

Where stack frame counts fit in field work, teaching, and software

On this page the work runs entirely in your browser; through the API each successful lookup costs $0.002, failed validation is not charged, and nothing is stored after the response returns. That split — free interactive exploration and a priced, identical API — matches the rest of the KIT tier-A catalog and lets you move from a classroom demo to an automated pipeline without changing the mathematical result.

Deterministic test fixtures

Generate reproducible frame_count, total_integration_seconds, and trail_arc_degrees values for unit tests, property checks, and CI assertions.

How is frame_count calculated?

frame_count equals the ceiling of desired_trail_seconds divided by single_exposure_seconds. That is the minimum number of equal sub-exposures whose open-shutter total covers the trail you want.

What if single_exposure_seconds is zero or negative?

The input is rejected with invalid_input. Non-positive exposure is not a valid open-shutter length for a stacked frame.

Does interval_seconds change the frame count?

No. Interval only lengthens total_session_seconds between frames. Frame count still depends only on desired trail duration and single exposure length.

Read the full KIT documentation →