ForHosting KIT · Science

Modified Julian Date calculator

Turn a Julian Date into the shorter Modified Julian Date that satellite teams and astronomy archives use: JD 2451545 becomes MJD 51544.5 once 2400000.5 days are subtracted. Fractions of a day are kept. 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

Julian date: 2,451,545

You get

Modified julian date: 51,544.5
Mjd: 51,544.5
Offset: 2,400,000.5

The Modified Julian Date is the standard day-count used in satellite operations, space-flight software, and many astronomy archives because it keeps day numbers compact and starts the civil day at midnight UT rather than noon. Observers, mission planners, and data pipelines often hold times as full Julian Dates and need a deterministic conversion to MJD for catalogs, telemetry windows, and cross-mission comparisons. This Modified Julian Date calculator accepts a finite Julian Date, subtracts the official offset 2400000.5 days, and returns the MJD with the formula and offset echoed for audit trails.

What Modified Julian Date means and why the 2400000.5 offset exists

A Julian Date counts days and fractions of a day continuously from a fixed astronomical epoch, with the day boundary at noon Universal Time so that a single night of observation rarely crosses a day number. That choice is convenient for night-time astronomy but awkward for civil schedules and modern computers that prefer midnight day starts and smaller integers. The Modified Julian Date was defined so that MJD equals the Julian Date minus exactly 2400000.5 days.

The half-day term shifts the day boundary from noon UT to midnight UT, and the 2400000 integer part drops the large leading digits that appear in current epoch JDs near 2.4 million. By definition, MJD 0.0 corresponds to JD 2400000.5, which is 1858-11-17 at 00:00 UT. Famous checkpoints include J2000.0 at JD 2451545.0, which is MJD 51544.5, and any later JD maps by the same linear shift.

Because the mapping is a pure constant subtraction, there is no calendar leap logic, no time-zone table, and no need for a system clock: two implementations that use the same JD input must return the same MJD to machine precision. This capability implements that definition and nothing else—it does not convert civil calendar strings, does not apply leap seconds, and does not invent a time scale beyond the continuous day count you supply as JD.

What you can do with it

Mission ops and telemetry alignment

Convert legacy Julian Date columns to Modified Julian Date for pass windows, telemetry archives, and ground-station schedules that standardize on MJD.

Catalog and FITS timestamp pipelines

Normalize research catalogs and header times that mix JD and MJD into a single continuous day count with a deterministic constant offset.

Teaching and SEO demos

Show students and site visitors MJD = JD − 2400000.5 with live examples such as J2000 (JD 2451545.0 → MJD 51544.5) in a free browser tool.

FAQ

What is the MJD offset from JD?

By definition MJD = JD − 2400000.5. The half day shifts noon UT to midnight UT; the integer part shortens modern day numbers.

Does this convert a calendar date to MJD?

No. Input must already be a Julian Date number. Convert a civil date to JD with a Julian Day Number tool first, then call this capability.

Why does the Modified Julian Date start at midnight?

Julian Dates change at noon Universal Time so a night of observing stays on one day number. The half-day in the offset moves the boundary to midnight, which suits civil schedules and computers better.

What is the MJD of Julian Date 2451545?

It is 51544.5. Subtract 2400000.5 from the Julian Date and you get the Modified Julian Date; any fraction of a day in your value carries through unchanged.

Who uses Modified Julian Dates?

Satellite operators, space-flight software and many astronomy archives. The smaller day numbers are easier to read and store, and they make it simple to compare catalogues, telemetry windows and missions.

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/astro/modified-julian-date

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/modified-julian-date \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d '{"julian_date":2451545}'

const res = await fetch("https://api.kit.forhosting.com/astro/modified-julian-date", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.KIT_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "julian_date": 2451545
  })
});
const { task_id } = await res.json();

import os, requests

res = requests.post(
    "https://api.kit.forhosting.com/astro/modified-julian-date",
    headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
    json={
    "julian_date": 2451545
},
)
task_id = res.json()["task_id"]

<?php
$res = file_get_contents("https://api.kit.forhosting.com/astro/modified-julian-date", false, stream_context_create([
  "http" => [
    "method"  => "POST",
    "header"  => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
    "content" => '{"julian_date":2451545}',
  ],
]));
$task = json_decode($res, true);

body := bytes.NewBufferString(`{"julian_date":2451545}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/astro/modified-julian-date", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)

Example request

{
  "julian_date": 2451545
}

Example response

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

Non-numeric or non-finite input fails with invalid_input and is not billed.

Input contract, response shape, and error behaviour

Values are rounded to twelve decimal places for stable cross-runtime goldens while remaining far more precise than typical observational timestamps. Failed validation does not consume balance. POST a JSON body with one required field, julian_date (aliases jd, julian_day, jd_value): a finite number or numeric string representing the Julian Date, including an optional fractional part for time of day after noon UT on the JD scale. Missing, empty, non-numeric, NaN, and Infinity values fail with invalid_input naming the field so clients can fix the payload without a generic 500. On success the body includes julian_date (echoed), modified_julian_date and mjd (identical values for convenience), offset equal to 2400000.5, and formula set to the string MJD = JD - 2400000.5. Example: julian_date 2451545.0 yields modified_julian_date 51544.5; julian_date 2400000.5 yields modified_julian_date 0. Negative JD values and pre-epoch historical counts are accepted when finite—the definition does not require JD greater than the MJD zero point—so laboratory tests and historical reconstructions can use the same endpoint. Pair this converter with a separate Julian Day Number calculator when you start from a calendar date, then feed the resulting JD here if your archive stores MJD; this endpoint only performs the offset step and never calls the network or system Date APIs.

Where a Modified Julian Date API earns its keep

Mission operations centers and CubeSat ground stations often log pass windows and telemetry in MJD while legacy ephemeris tables still quote JD; a single prepaid conversion call keeps those columns aligned without shipping a custom constants file into every microservice. Keep requests small, pin the rounded modified_julian_date in tests, and you get reproducible day counts for operations dashboards, archival pipelines, and classroom homework without standing up a full time-scale library of your own.

Technical questions

How do I convert Julian Date to Modified Julian Date?

Send a finite julian_date (or jd). The API returns modified_julian_date = julian_date − 2400000.5, plus the offset and formula string for display.

What happens if julian_date is non-numeric?

The task fails with invalid_input. Missing, empty, NaN, Infinity, and non-numeric strings are rejected and not billed.

What does the Modified Julian Date 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