Unix time converter
Unix time 0 is midnight UTC on 1 January 1970. Turn any whole-second epoch timestamp, negative ones included, into the UTC year, month, day, hour, minute and second, plus a date-time string ready for a log or a ticket. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Timestamp
- 0
- Year
- 1,970
- Month
- 1
- Day
- 1
- Hour
- 0
A Unix time converter turns that integer into a calendar date and a clock time that a human can read: year, month, day, hour, minute, and second, always in UTC. This tool accepts a finite integer timestamp in seconds, splits it into a UTC day index and a time of day with floor division, maps the day index onto the proleptic Gregorian calendar with published civil-from-days arithmetic, and returns a deterministic UTC date-time string of the form YYYY-MM-DDTHH:mm:ssZ. Negative integers are first-class: they encode instants before the epoch, such as 31 December 1969.
What Unix time counts and how the UTC calendar is recovered
Unix time, also called epoch time or POSIX time, is a signed count of whole seconds elapsed since 1970-01-01T00:00:00Z, ignoring leap seconds. Operating systems, JWT claims, database columns, and observability backends store instants this way because an integer has no month-name ambiguity, no locale separator, and no daylight-saving branch. Humans still need a calendar face: which year, month, and day, and what hour, minute, and second on the UTC clock.
Recovering that face is pure arithmetic. Divide the integer by 86400 with floor division to obtain a day index relative to 1 January 1970 and a non-negative remainder that is the second of that UTC day. Map the day index through the proleptic Gregorian civil-from-days algorithm, using the same era and day-of-era constants published for civil-time libraries, to year, month, and day.
Split the remainder by 3600 and 60 for hour, minute, and second. Format the six civil fields as a UTC date-time string YYYY-MM-DDTHH:mm:ssZ. Zero is midnight at the epoch.
Negative one is 1969-12-31T23:59:59Z. One billion is the well-known billionth Unix second on 9 September 2001 at 01:46:40 UTC. This landing answers the search unix time: given an integer second count, what is the UTC calendar date and time, with no local offset and no fractional-second guesswork.
The mapping never consults a wall clock, so the same integer always yields the same string in tests and in production.
Whole seconds in, a UTC date out
The integer-only rule is the product contract: POSIX Unix time is a second count, not a millisecond count and not a floating clock. If a vendor sent milliseconds, divide by one thousand in the caller and send the whole-second result. On success the body echoes timestamp as the coerced integer; year, month, day, hour, minute, and second as UTC civil components; datetime as the UTC date-time string with a Z designator; timezone as the constant UTC; formula as the fixed identity; and message as a one-line summary.
Failed validation is never billed. Prefer asserting the datetime string and the echoed components in automated tests rather than re-deriving calendar math by hand in every client. Civil years after conversion must fall in 0001 through 9999; values that map outside that window are rejected instead of formatted with overflow.
Where a Unix time converter earns its keep, and what it is not
Incident responders paste a raw second count from a stack trace or log line and need a UTC calendar instant for the postmortem timeline without trusting the laptop timezone. Data pipelines normalize integer epoch columns into UTC date-time strings before warehouse loads and audit exports. Engineering teams pin datetime for known inputs so client and server formatting never disagree across runtimes.
Keep milliseconds out of this contract: divide them first, or you will land in the year 50,000s. Output is always UTC with a Z suffix—there is no named timezone database and no daylight-saving branch—so dashboards that need city-local display apply their own offset after this conversion. This landing targets people searching for unix time, unix time converter, or epoch timestamp to UTC date.
It is not a bidirectional epoch converter that also turns dates back into integers, not an NTP timestamp converter, not a duration unit converter (seconds versus hours), and not a fractional ISO 8601 formatter that accepts sub-second residue. Prefer this capability when you already have a whole-second count and only need the UTC calendar string.
What you can do with it
Incident log triage in UTC
Paste a raw Unix second value from a stack trace or log line and get a deterministic UTC calendar date-time for the postmortem timeline.
ETL of integer epoch columns
Data pipelines convert whole-second epoch columns into UTC date-time strings before warehouse loads, audit exports, and downstream joins.
FAQ
How do I convert Unix time to a UTC date and time?
Send a finite integer timestamp (whole seconds since 1970-01-01T00:00:00Z).
Why are fractional timestamps rejected?
POSIX Unix time is a count of whole seconds.
Does the converter use the local timezone?
No. Output is always UTC with a Z designator. Apply a local offset after conversion if a city wall clock is required.
What about timestamps before 1970 or the billionth Unix second?
Negative integers are valid: −1 is 1969-12-31T23:59:59Z. The integer 1000000000 is 2001-09-09T01:46:40Z. Zero is the epoch midnight.
What if my timestamp is in milliseconds?
Divide it by 1000 first and enter the whole-second result. Unix time here is a count of seconds, not milliseconds, and a number with decimals is refused rather than rounded.
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/conv/unix-time \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"timestamp":1000000000}'const res = await fetch("https://api.kit.forhosting.com/conv/unix-time", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"timestamp": 1000000000
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/conv/unix-time",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"timestamp": 1000000000
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/conv/unix-time", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"timestamp":1000000000}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"timestamp":1000000000}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/conv/unix-time", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"timestamp": 1000000000
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "conv.unix_time",
"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
Unix time is the integer count of whole seconds since midnight Coordinated Universal Time on 1 January 1970, the epoch used by Unix-like kernels, JSON APIs, databases, and log pipelines. Fractional timestamps, infinities, and non-numeric values are rejected as invalid_input rather than silently rounded, because a half-second epoch is not a POSIX second count.
Input contract, integer-only rule, and the response shape
POST a JSON body with the required field timestamp set to a finite integer (whole seconds since the Unix epoch). Aliases unix, epoch, ts, seconds, and unix_time are accepted and coerced the same way. Numeric strings that match an optional sign plus digits are accepted when a form posts text; scientific notation in a string, empty strings, booleans, objects, infinities, NaN, and any non-integer number fail with invalid_input naming timestamp. Pricing is a flat $0.002 per successful request with unit item.
Where a Unix time converter earns its keep, and what it is not
Failed tasks that return invalid_input do not consume prepaid balance, which keeps exploratory scripts cheap when learners deliberately send garbage strings.
Integration use cases
Pinned fixtures for time APIs
Engineering teams pin datetime for known integer inputs so client and server calendar formatting never disagree across runtimes.
Technical questions
What does the Unix time converter cost?
The browser tool is free. API requests use prepaid balance at $0.002 per successful call; invalid input is not billed.