enhost NTP Server Time

Windows 11/10:

1. Open Settings → Time & Language → Date & Time

2. Scroll down and click "Additional clocks"

3. Click "Internet Time" tab → "Change settings"

4. Enter time.enhost.uk (or pool.ntp.org) as the server

5. Click "Update now" then "OK"

macOS Ventura or later:

1. Open System Settings → General → Date & Time

2. Click the info (ⓘ) button next to "Set time and date automatically"

3. Enter time.enhost.uk (or pool.ntp.org) as the time server

4. Click "OK"

macOS Monterey or earlier:

1. Open System Preferences → Date & Time

2. Click the lock to make changes

3. Click "Set time and date automatically" and enter time.enhost.uk (or pool.ntp.org)

Using AtomicClock App (macOS/iOS):

1. Install AtomicClock - NTP Time from the App Store

2. Open the app and go to Settings

3. Enter time.enhost.uk (or pool.ntp.org) as the NTP server

4. Use the app to view accurate time from our server

Using AtomicClock App:

iOS doesn't allow changing the system NTP server, but you can use an app to view accurate time from our server.

1. Install AtomicClock - NTP Time from the App Store

2. Open the app and go to Settings

3. Enter time.enhost.uk (or pool.ntp.org) as the NTP server

4. Use the app to view accurate time from our server

Note: This app displays the accurate time but cannot synchronize your iOS device's system clock. iOS automatically syncs with Apple's time servers.

systemd-timesyncd (Ubuntu/Debian):

sudo nano /etc/systemd/timesyncd.conf

Add under [Time]:

NTP=time.enhost.uk

(or use pool.ntp.org)

Then restart:

sudo systemctl restart systemd-timesyncd

chrony (RHEL/CentOS/Fedora):

echo "server time.enhost.uk iburst" | sudo tee -a /etc/chrony.conf

(or use pool.ntp.org)

sudo systemctl restart chronyd

NixOS:

Add to your configuration.nix:

networking.timeServers = [ "time.enhost.uk" ];

(or use [ "pool.ntp.org" ])

Then rebuild:

sudo nixos-rebuild switch

Standard Android:

Android uses automatic time from cellular networks by default and doesn't allow custom NTP servers through settings.

Using AtomicClock App (No Root):

1. Install AtomicClock - NTP Time from Google Play

2. Open the app and go to Settings

3. Enter time.enhost.uk (or pool.ntp.org) as the NTP server

4. Use the app to view accurate time from our server

With Root Access:

1. Install ClockSync from F-Droid

2. Open the app and grant root permissions

3. Enter time.enhost.uk (or pool.ntp.org) as the NTP server

4. Enable automatic sync

Query the NTP server directly from the command line:

Using ntpdate (query only):

ntpdate -q time.enhost.uk

Using ntpdate (sync immediately, requires root):

sudo ntpdate time.enhost.uk

Using sntp:

sntp time.enhost.uk

Using ntpq (query NTP daemon):

ntpq -p time.enhost.uk

Using chronyc (if using chrony):

chronyc tracking

Raw UDP query with netcat:

printf '\x1b' | nc -u -w1 time.enhost.uk 123 | od -A x -t x1z -v

Note: NTP uses UDP on port 123, so standard tools like cURL and telnet won't work.

Get NTP time via HTTP API:

https://time.enhost.uk/

Note: This API includes processing delay from querying the NTP server and PHP execution time. The processing_time_ms field shows how long the server took to process the request. For time-critical applications, use the NTP protocol directly (port 123).

JSON response (with Accept: application/json header):

{
    "success": true,
    "enhost_ntp": {
        "server": "time.enhost.uk",
        "timestamp": 1707494400,
        "timestamp_ms": 1707494400000,
        "unix_timestamp": 1707494400.123,
        "iso8601": "2024-02-09T16:00:00.000Z",
        "rfc2822": "Fri, 09 Feb 2024 16:00:00 GMT",
        "ntp_request_time_ms": 8.3,
        "processing_time_ms": 8.3
    },
    "uk_pool_ntp": { "...": "same shape, from uk.pool.ntp.org" },
    "swatch_internet_time": {
        "beats": 750.0,
        "beat": 750,
        "display": "@750.00",
        "reference": "Biel Mean Time (UTC+1), 1000 beats per day"
    },
    "timezone": {
        "name": "Europe/London",
        "abbreviation": "GMT",
        "utc_offset": "+00:00",
        "offset_seconds": 0,
        "local_time": "2024-02-09 16:00:00",
        "iso8601": "2024-02-09T16:00:00.000+00:00",
        "dst": false,
        "next_transition": {
            "at": "2024-03-31T01:00:00Z",
            "at_local": "2024-03-31 02:00:00",
            "abbreviation": "BST",
            "utc_offset": "+01:00",
            "offset_seconds": 3600,
            "dst": true,
            "shift_seconds": 3600,
            "direction": "forward"
        }
    },
    "decimal_time": {
        "hours": 5, "minutes": 0, "seconds": 0,
        "display": "5:00:00",
        "decimal_seconds": 50000.0,
        "timezone": "Europe/London",
        "reference": "10 hours of 100 minutes of 100 seconds, from local midnight"
    },
    "leap_seconds": {
        "tai_utc_offset": 37,
        "gps_utc_offset": 18,
        "inserted": 27,
        "last_inserted": "2017-01-01",
        "note": "TAI = UTC + 37s. ..."
    },
    "gps_time": {
        "gps_seconds": 1475785836,
        "week": 2440,
        "week_legacy": 392,
        "seconds_of_week": 73836,
        "day_of_week": 0,
        "gps_utc_offset": 18,
        "rollovers_so_far": 2,
        "last_rollover": "2019-04-07",
        "next_rollover": "2038-11-21",
        "note": "..."
    },
    "upcoming_rollovers": [
        { "name": "NTP era 0", "at": "2036-02-07 06:28:16", "years_away": 9, "note": "..." },
        { "name": "Unix 32-bit time_t", "at": "2038-01-19 03:14:07", "years_away": 11, "note": "..." },
        { "name": "GPS week number", "at": "2038-11-21 00:00:00", "years_away": 12, "note": "..." }
    ],
    "other_scales": {
        "iso_week_date": "2026-W41-7", "ordinal_date": "2026-284",
        "julian_date": 2461325.37766, "modified_julian_date": 61324.87766,
        "sidereal_time": "22:25:41",
        "mars_sol_date": 54310.31699, "mars_coordinated_time": "07:36:27",
        "kiloseconds": 79.43, "hexadecimal": ".EB59",
        "timezone": "Europe/London",
        "tick": { "...": "value plus rate, so a client can tick these without the formulae" }
    },
    "offset_ms": -1.2,
    "processing_time_ms": 12.5
}

Headers-only response (HEAD request):

For minimal overhead, use a HEAD request to get time data in response headers only:

X-NTP-Timestamp: 1707494400
X-NTP-Timestamp-Ms: 1707494400000
X-NTP-ISO8601: 2024-02-09T16:00:00.000Z
X-NTP-RFC2822: Fri, 09 Feb 2024 16:00:00 GMT
X-NTP-Request-Time-Ms: 8.3
X-NTP-Processing-Time-Ms: 12.5
X-NTP-Offset-Ms: -1.2

HEAD carries the time and this request's own timings only. Every other scale on this page — .beat, decimal, Julian, sidereal, Martian, GPS, the timezone block and the upcoming rollovers — is in the JSON response instead, so a HEAD stays cheap.

Timezone:

Add tz= with an IANA name to get the same instant as a local wall clock in the timezone block, along with the zone's next daylight-saving change in next_transition (null for zones that have none). Timestamps and iso8601 stay UTC regardless. Defaults to UTC; an unknown name returns HTTP 400.

curl 'https://time.enhost.uk/?json=1&tz=Asia/Tokyo'

Using cURL (JSON):

curl -H "Accept: application/json" https://time.enhost.uk/

Using cURL (HEAD request):

curl -I https://time.enhost.uk/?json

Using JavaScript/Fetch:

fetch('https://time.enhost.uk/', {
    headers: { 'Accept': 'application/json' }
})
    .then(res => res.json())
    .then(data => console.log(data.iso8601));

Using the ntp-client package:

const ntpClient = require('ntp-client');

ntpClient.getNetworkTime('time.enhost.uk', 123, (err, date) => {
    if (err) {
        console.error(err);
        return;
    }
    console.log('Current time:', date);
});

Install with: npm install ntp-client

Or using the HTTP API with axios:

const axios = require('axios');

axios.get('https://time.enhost.uk/', {
    headers: { 'Accept': 'application/json' }
})
    .then(response => {
        console.log('Time:', response.data.iso8601);
    });

Using the ntplib library:

import ntplib
from time import ctime

client = ntplib.NTPClient()
response = client.request('time.enhost.uk')
print(ctime(response.tx_time))

Install with: pip install ntplib

Using sockets to query NTP server:

$server = 'time.enhost.uk';
$port = 123;
$socket = socket_create(AF_INET, SOCK_DGRAM, SOL_UDP);
socket_set_option($socket, SOL_SOCKET, SO_RCVTIMEO,
    array('sec' => 5, 'usec' => 0));

$msg = chr(0x1b) . str_repeat(chr(0), 47);
socket_sendto($socket, $msg, strlen($msg), 0, $server, $port);
socket_recvfrom($socket, $response, 48, 0, $server, $port);

$data = unpack('N12', $response);
$timestamp = $data[11] - 2208988800;
echo date('Y-m-d H:i:s', $timestamp);

Using the rsntp crate:

use rsntp::SntpClient;

fn main() {
    let client = SntpClient::new();
    let result = client.synchronize("time.enhost.uk")
        .unwrap();

    println!("Time: {:?}", result.datetime());
}

Add to Cargo.toml: rsntp = "3.0"

Using UDP sockets to query NTP server:

#include <stdio.h>
#include <string.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netdb.h>
#include <time.h>

#define NTP_TIMESTAMP_DELTA 2208988800ull

int main() {
    int sockfd;
    char packet[48] = {0x1b, 0};
    struct sockaddr_in serv_addr;
    struct hostent *server;

    server = gethostbyname("time.enhost.uk");
    sockfd = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);

    memset(&serv_addr, 0, sizeof(serv_addr));
    serv_addr.sin_family = AF_INET;
    memcpy(&serv_addr.sin_addr.s_addr, server->h_addr, server->h_length);
    serv_addr.sin_port = htons(123);

    sendto(sockfd, packet, sizeof(packet), 0,
           (struct sockaddr *)&serv_addr, sizeof(serv_addr));
    recvfrom(sockfd, packet, sizeof(packet), 0, NULL, NULL);

    unsigned long secsSince1900 = (packet[40] << 24) | (packet[41] << 16) |
                                  (packet[42] << 8) | packet[43];
    time_t epoch = secsSince1900 - NTP_TIMESTAMP_DELTA;
    printf("Time: %s", ctime(&epoch));

    return 0;
}

Compile with: gcc -o ntp_client ntp_client.c