Convert .NET ticks to an ISO date and time
The ticks value 638712864000000000 is midnight on 1 January 2025, UTC. Paste any count of 100-nanosecond steps since the start of year 1 and get the full date and time, plus the date and the time shown separately. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Ticks
- 638712864000000000
- Iso datetime
- 2025-01-01T00:00:00.0000000Z
- Date
- 2025-01-01
- Time
- 00:00:00.0000000Z
Convert a . NET DateTime ticks value into an unambiguous ISO datetime in UTC without relying on a computer's local timezone or date parser. The converter treats the input as the number of 100-nanosecond intervals since midnight on January 1, year 1 in the proleptic Gregorian calendar. It returns a normalized ticks string, a complete ISO datetime with seven fractional-second digits, and separate date and time fields.
Understand what a .NET tick represents
A . NET DateTime tick is one 100-nanosecond interval, so ten million ticks make one second and 864 billion ticks make one day. The origin is 0001-01-01 at 00:00:00, not the Unix epoch used by many other timestamps. This converter divides the exact integer into whole Gregorian days and the remainder within the day.
It then resolves the year, month, and day according to the leap-year rules used by DateTime. The complete result ends in Z because the calculation is presented deterministically as UTC. Seven digits follow the decimal point in the seconds field, preserving the resolution of the input instead of rounding it to milliseconds.
Submit ticks as decimal text. Leading zeroes are accepted and the normalized ticks field in the response removes them, making comparisons and storage consistent. The date and time fields are also returned separately for workflows that do not need to split the ISO value themselves.
Convert values without timezone surprises
The calculation does not consult the machine clock, locale, operating-system timezone, daylight-saving rules, or a built-in date parser. That matters when the same archived value is inspected in a browser, a server job, and a developer workstation located in different regions. Given the same tick string, every environment receives the same calendar components and the same ISO datetime.
The trailing Z expresses the requested UTC interpretation; it is not inferred from hidden DateTime Kind metadata, because a bare tick count does not contain that metadata. If the source application originally treated its DateTime as local or unspecified, determine the intended timezone before using this result as an absolute moment in another system. The converter intentionally performs no local-to-UTC offset adjustment.
It maps the numeric count directly from the year-one epoch and labels that deterministic computation as UTC. This distinction prevents an apparently helpful timezone conversion from silently changing historical data. Values at leap days, century boundaries, midnight, and the maximum DateTime instant follow the proleptic Gregorian rules and remain stable across runs.
Validate and integrate the returned ISO datetime
The accepted range is zero through 3155378975999999999, matching the representable DateTime span from the first instant of year 1 through the final 100-nanosecond interval of year 9999. Inputs must contain decimal digits only. Negative values, exponents, decimal points, signs, separators, and values beyond the maximum are rejected rather than guessed or rounded.
This strict contract is useful in migrations because malformed records fail visibly instead of producing plausible but incorrect dates. Some databases and JavaScript libraries retain only milliseconds or microseconds; check the destination before importing if the last digits are important. Use the separate date field for partition keys and reporting labels, and the time field when preserving the within-day component independently.
What you can do with it
Inspect legacy database rows
Turn an opaque ticks column into readable UTC dates while checking records during a migration.
Debug serialized .NET values
Confirm the calendar instant represented by ticks in logs, cache entries, or exported application state.
FAQ
What is the epoch for .NET DateTime ticks?
The count begins at 0001-01-01T00:00:00.0000000 in the proleptic Gregorian calendar.
Does a ticks value include timezone information?
No. A bare count does not carry DateTime Kind or a local offset. This capability computes and labels the result deterministically in UTC without applying an offset.
How much precision is retained?
All seven fractional-second digits are retained, corresponding to the 100-nanosecond resolution of one tick.
What values are accepted?
Decimal integers from 0 through 3155378975999999999 are accepted. Signs, fractions, exponents, and out-of-range values are rejected.
How long is one .NET tick?
One tick is 100 nanoseconds. Ten million ticks make one second and 864 billion make one day, counted from midnight at the start of year 1, not from the Unix epoch.
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/date/dotnet-ticks-to-date \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"ticks":"638712864000000000"}'const res = await fetch("https://api.kit.forhosting.com/date/dotnet-ticks-to-date", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"ticks": "638712864000000000"
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/date/dotnet-ticks-to-date",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"ticks": "638712864000000000"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/date/dotnet-ticks-to-date", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"ticks":"638712864000000000"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"ticks":"638712864000000000"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/date/dotnet-ticks-to-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
{
"ticks": "638712864000000000"
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "date.dotnet_ticks_to_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
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
This makes old database values, serialized application records, logs, and integration payloads easier to inspect and move between systems while retaining the precision present in the original value.
Understand what a .NET tick represents
Text avoids precision loss in software environments where ordinary JSON numbers cannot exactly represent large 64-bit integers.
Validate and integrate the returned ISO datetime
Use iso_datetime when writing a text export, audit report, or API payload that supports seven fractional digits.
Integration use cases
Normalize integration payloads
Convert DateTime tick strings to stable ISO datetimes before sending data to systems that use textual timestamps.
Technical questions
Why should ticks be supplied as text?
Large tick values exceed the exact integer range of common JSON number implementations. Decimal text preserves every digit.
What does an API conversion cost?
Each conversion costs $0.002.