--- url: https://findutils.com/guides/unix-timestamp-converter-guide title: "Unix Timestamp Converter: Seconds, Milliseconds, UTC" description: "Use a Unix timestamp converter to check seconds, milliseconds, UTC, and local dates. Follow worked examples and learn the browser and API conversion limits." category: developer content_type: guide locale: en read_time: 7 status: published author: "FindUtils Team" published_at: 2026-09-09T08:45:00Z updated_at: 2026-09-09T08:45:00Z excerpt: "Convert epoch values with explicit units. Compare UTC and local output, enter dates carefully, and understand the different browser and API input rules." tag_ids: ["developer-tools", "unix", "timestamps", "time"] tags: ["Developer Tools", "Unix", "Timestamps", "Time"] primary_keyword: "unix timestamp converter" secondary_keywords: ["epoch to date", "convert milliseconds to date", "date to Unix timestamp", "Unix timestamp UTC"] tool_tag: "unix-timestamp" related_tool: "unix-timestamp" related_tools: ["unix-timestamp", "timezone-converter", "json-formatter"] guide_type: subtopic cluster: time og_image: "/images/content/guides/unix-timestamp-seconds-milliseconds.webp" image_alt: "A mechanical time counter feeds blue measurement tape toward a calendar and two separate tick scales." --- A Unix timestamp converter turns an epoch value into a readable date. Use the FindUtils [Unix Timestamp Converter](/developers/unix-timestamp/) to compare UTC, local time, and ISO output, after you confirm the input unit. For example, `1788912000` seconds and `1788912000000` milliseconds both identify September 9, 2026, at midnight UTC. This guide explains those conversions, reverse conversion, and the current limits of the browser and API tools. ## What does a Unix timestamp represent? A Unix timestamp normally counts seconds from January 1, 1970, at `00:00:00` UTC. A millisecond timestamp uses the same origin with 1,000 units per second. Ordinary Unix time does not count leap seconds as additional elapsed seconds. See the [POSIX time rationale](https://pubs.opengroup.org/onlinepubs/007904975/xrat/xbd_chap04.html). The unit belongs to the data contract. A number alone does not identify seconds or milliseconds. JavaScript `Date` uses milliseconds, as the [MDN Date reference](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date) explains. Use a conversion when you need to inspect: - **An event time:** Identify when a request or background task occurred. - **An API field:** Compare a returned number with the expected calendar date. - **A log entry:** Read an event in UTC before comparing it with another system. - **A date boundary:** Check the exact instant that starts or ends a reporting period. Do not treat a timestamp as proof that a device clock was correct. Conversion changes the representation of the supplied value. ## How do you convert a timestamp to a date? Confirm the unit, enter a clean integer, and compare the ISO result with an expected date. The browser tool updates its result when you change the input. ### Step 1: Open the converter Open the [Unix Timestamp Converter](/developers/unix-timestamp/). Select **Timestamp to Date**. If you start with an API response, use the [JSON Formatter](/developers/json-formatter/) to locate the relevant field first. ### Step 2: Confirm the input unit Read the source field's documentation. For a contemporary date, seconds often have 10 digits and milliseconds often have 13 digits. These lengths are clues, not a format guarantee. ### Step 3: Enter the complete integer Enter `1788912000` without quotes, spaces, separators, or a unit suffix. The UTC result identifies September 9, 2026, at midnight. The ISO result is `2026-09-09T00:00:00.000Z`. ### Step 4: Compare the output representations Read the UTC and ISO values first. The local result uses your browser's time zone. A local calendar date can differ from the UTC date without changing the represented instant. ### Step 5: Keep the unit with the copied value Record the input as `1788912000 seconds`, or use a field name such as `occurred_at_seconds`. When you copy the ISO result, keep its final `Z`. ## Which example values can you check? These synthetic examples use explicit units and expected UTC results. They provide reference points for a conversion, rather than evidence about your own source data. | Input | Declared unit | Expected ISO result | |---|---|---| | `0` | Seconds | `1970-01-01T00:00:00.000Z` | | `946684800` | Seconds | `2000-01-01T00:00:00.000Z` | | `1788912000` | Seconds | `2026-09-09T00:00:00.000Z` | | `1788912000000` | Milliseconds | `2026-09-09T00:00:00.000Z` | | `1788912000123` | Milliseconds | `2026-09-09T00:00:00.123Z` | The last row preserves 123 milliseconds. Converting that value into an integer number of seconds removes this fraction. Keep the original value when you need the original precision. For a JavaScript conversion with an explicit unit: ```javascript const seconds = 1788912000; const milliseconds = seconds * 1000; const iso = new Date(milliseconds).toISOString(); // 2026-09-09T00:00:00.000Z ``` Multiplication by 1,000 belongs at the seconds-to-milliseconds boundary. Do not apply it again to a value that already uses milliseconds. ## How do you convert a date to a Unix timestamp? The browser's **Date to Timestamp** form interprets the entered date and time in your local zone. It returns seconds and milliseconds. The form does not provide a UTC-zone selector. 1. Select **Date to Timestamp**. 2. Enter the intended calendar date yourself. 3. Enter the complete local clock time. 4. Copy the result with its seconds or milliseconds label. 5. Convert the copied result back to a date to check the instant. Enter both fields even when they already contain values. The current initial values combine a UTC calendar date with a local clock time. Near a date boundary, that combination can identify the wrong day. For an exact UTC date, use an explicitly qualified string in code: ```javascript const milliseconds = Date.parse('2026-09-09T00:00:00Z'); const seconds = Math.floor(milliseconds / 1000); // milliseconds: 1788912000000 // seconds: 1788912000 ``` Do not remove the `Z` from this example. JavaScript interprets a date-and-time string without an offset as local time. The [Date.parse documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/parse) describes this rule. ## Which conversion method should you use? Use the browser for a manual check of a known contemporary value. Use an explicit-unit conversion when your application needs repeatable parsing rules. | Method | Numeric input rule | Useful purpose | Limit to check | |---|---|---|---| | FindUtils browser converter | Guesses units from raw input length | Inspect one value with UTC and local output | Long, padded, or historical values can defeat the guess | | FindUtils REST or MCP converter | `to_date` accepts seconds | Convert a documented seconds field | Do not pass milliseconds directly | | JavaScript numeric `Date` constructor | Accepts milliseconds | Convert within application code | Convert seconds exactly once | | Qualified date string | Includes `Z` or a numeric offset | Share a readable instant | Keep the offset and required precision | The [REST reference](/api/unix-timestamp-convert/) and [MCP reference](/mcp/unix-timestamp-convert/) document the programmatic interface. Its `to_timestamp` result uses whole seconds, while its ISO result can retain milliseconds. The browser conversion code processes the entered values locally. This statement concerns conversion input. Read the [Privacy Policy](/privacy-policy/) for website data practices. Use synthetic values when a real log contains private information. ## What input mistakes should you avoid? Most checks begin with three questions: which unit does the source declare, which zone does the date use, and what precision must survive? ### Mistake 1: Treating unit detection as validation The current browser tool treats input longer than 10 characters as milliseconds. It counts raw characters, including spaces and signs. Enter clean values and use explicit-unit code for unusual ranges or historical millisecond values. ### Mistake 2: Adding a suffix or separator Do not enter `1788912000s` or `1,788,912,000`. The converter uses permissive integer parsing. A displayed date does not prove that it accepted every character as intended. ### Mistake 3: Reading local output as UTC Compare the ISO result before you conclude that two systems disagree. Use the [Timezone Converter](/productivity/timezone-converter/) when the task concerns a named destination zone. ### Mistake 4: Losing fractional precision The whole-second value for `1788912000123` milliseconds is `1788912000`. A reverse conversion gives `1788912000000` milliseconds. The discarded 123 milliseconds cannot return automatically. ### Mistake 5: Treating zero as missing Zero identifies the Unix epoch. Define missing data separately, such as an absent field or a documented `null`. Do not replace a missing timestamp with zero unless that behavior is intentional. ## Tools used in this guide These tools support different parts of the date review: - **[Unix Timestamp Converter](/developers/unix-timestamp/):** Inspect epoch values and local date input. - **[Timezone Converter](/productivity/timezone-converter/):** Compare clock times across named zones. - **[JSON Formatter](/developers/json-formatter/):** Read timestamp fields inside a JSON example. ## FAQ **Q: Does the Unix timestamp converter accept milliseconds?** A: The browser tool uses input length to detect milliseconds. Its REST and MCP `to_date` mode accepts seconds. Confirm which interface you use. **Q: Why does my timestamp show a date in 1970?** A: Check whether a seconds value reached an input that expects milliseconds. For example, `1788912000` milliseconds identifies January 21, 1970, at `16:55:12` UTC. **Q: Does changing the display zone change the timestamp?** A: Displaying the same instant in another zone keeps the timestamp unchanged. Entering a local date without an offset is a different operation. **Q: Can I use digit count to identify the unit?** A: Only as an initial clue. Older millisecond values can be short, and later second values can exceed 10 digits. The source contract decides the unit. **Q: Does the date form use UTC?** A: No. The browser form uses local time. Use a qualified date string with `Z` when you need an exact UTC input. **Q: Does a successful conversion prove the input is valid?** A: No. The current parsers accept some partial numeric input. Validate the full field, unit, and accepted range in the receiving application. ## Next steps Use [Unix timestamp seconds vs milliseconds](/blog/unix-timestamp-seconds-vs-milliseconds/) to review a data exchange. It provides a contract table and a diagnostic sequence. For a scheduling task, read the [Timezone Converter guide](/guides/timezone-converter-guide/). For a repeating task, read the [Cron Expression Generator guide](/guides/cron-expression-generator-guide/).