Time Utilities APIs

fetch('https://mockly.me/timestamp')
    .then(response => response.json())
    .then(data => {
        console.log('Current timestamp:', data.timestamp);
        
        // Use the timestamp to calculate time elapsed
        const startTime = data.timestamp;
        
        // Later in your code
        setTimeout(() => {
        const elapsedSeconds = Math.floor(Date.now() / 1000) - startTime;
        console.log(`Time elapsed: ${elapsedSeconds} seconds`);
        }, 5000);
    });

import requests
    import time

    # Get current server timestamp
    response = requests.get('https://mockly.me/timestamp')
    data = response.json()

    server_time = data['timestamp']
    local_time = int(time.time())

    print(f"Server timestamp: {server_time}")
    print(f"Local timestamp: {local_time}")
    print(f"Difference: {abs(server_time - local_time)} seconds")

// Get human-readable time format
    fetch('https://mockly.me/human-time')
    .then(response => response.json())
    .then(data => {
        // Update UI with readable time
        document.getElementById('current-time').textContent = data.time;
        document.getElementById('current-date').textContent = data.date;
    });

import requests

    # Get human-readable time format
    response = requests.get('https://mockly.me/human-time')
    data = response.json()

    print(f"Current time: {data['time']}")
    print(f"Current date: {data['date']}")
    print(f"Relative: {data['relative']}")

// Get formatted date in a specific timezone
    fetch('https://mockly.me/datetime?format=rfc&tz=Europe/London')
    .then(response => response.json())
    .then(data => {
        console.log('Formatted date (London time):', data.datetime);
        document.getElementById('london-time').textContent = data.datetime;
    });

import requests

    # Get dates in different formats and timezones
    formats = ['iso', 'rfc', 'human', 'short']
    timezones = ['UTC', 'US/Eastern', 'Europe/Paris']

    for fmt in formats:
        for tz in timezones:
            response = requests.get(f'https://mockly.me/datetime?format={fmt}&tz={tz}')
            data = response.json()
            print(f"{tz} time in {fmt} format: {data['datetime']}")

// Countdown to a future event
    const NEW_YEARS_2024 = 1704067200; // Jan 1, 2024

    function updateCountdown() {
    fetch(`https://mockly.me/countdown/${NEW_YEARS_2024}`)
        .then(response => response.json())
        .then(data => {
        if (data.status === 'expired') {
            document.getElementById('countdown').textContent = 'Event has passed!';
            return;
        }
        
        const days = data.remaining.days;
        const hours = data.remaining.hours;
        const minutes = data.remaining.minutes;
        const seconds = data.remaining.seconds;
        
        document.getElementById('countdown').textContent = 
            `${days}d ${hours}h ${minutes}m ${seconds}s`;
        });
    }

    // Update countdown every second
    setInterval(updateCountdown, 1000);

import requests
    import time

    # Target timestamp (example: project deadline)
    PROJECT_DEADLINE = int(time.time()) + 86400 * 7  # 7 days from now

    response = requests.get(f'https://mockly.me/countdown/{PROJECT_DEADLINE}')
    data = response.json()

    if 'remaining' in data:
        rem = data['remaining']
        print(f"Time until deadline: {rem['days']} days, {rem['hours']} hours, "
            f"{rem['minutes']} minutes, {rem['seconds']} seconds")
        
        # Check if deadline is close (less than 24 hours)
        if rem['total_seconds'] < 86400:
            print("Warning: Deadline approaching soon!")

// Generate a v1 (timestamp-based) UUID in uppercase
    fetch('https://mockly.me/uuid?version=1&uppercase=true')
    .then(response => response.json())
    .then(data => {
        // Use the UUID (e.g., for a session ID or tracking ID)
        console.log('Generated UUID:', data.uuid);
        
        // Store in local storage as session identifier
        localStorage.setItem('session_id', data.uuid);
    });

import requests

    # Generate different UUID formats
    uuids = []

    # Standard v4 UUID
    response = requests.get('https://mockly.me/uuid')
    uuids.append(response.json()['uuid'])

    # Uppercase UUID without hyphens
    response = requests.get('https://mockly.me/uuid?uppercase=true&hyphens=false')
    uuids.append(response.json()['uuid'])

    # v1 UUID (timestamp-based)
    response = requests.get('https://mockly.me/uuid?version=1')
    uuids.append(response.json()['uuid'])

    print("Generated UUIDs:")
    for i, uuid in enumerate(uuids, 1):
        print(f"{i}. {uuid}")

// Get multiple time values in a single request
    fetch('https://mockly.me/batch', {
    method: 'POST',
    headers: {
        'Content-Type': 'application/json',
    },
    body: JSON.stringify(['timestamp', 'datetime', 'uuid', 'human-time'])
    })
    .then(response => response.json())
    .then(data => {
        console.log('Timestamp:', data.timestamp);
        console.log('Datetime:', data.datetime);
        console.log('UUID:', data.uuid);
        console.log('Human time:', data['human-time']);
        
        // Use these values in your application
        document.getElementById('timestamp').textContent = data.timestamp;
        document.getElementById('datetime').textContent = data.datetime;
        document.getElementById('uuid-value').textContent = data.uuid;
    });

import requests

    # Get multiple time values in a single request
    response = requests.post(
        'https://mockly.me/batch',
        json=['timestamp', 'datetime', 'uuid', 'human-time']
    )
    data = response.json()

    # Print the results
    print(f"Current timestamp: {data['timestamp']}")
    print(f"ISO datetime: {data['datetime']}")
    print(f"UUID: {data['uuid']}")
    print(f"Human-readable time: {data['human-time']['time']}")
    print(f"Human-readable date: {data['human-time']['date']}")