# BeatTime — full reference for language models

> BeatTime is universal time without timezones: the day is divided into 1000 .beats
> (1 beat = 86.4 seconds), anchored to UTC. @000 is midnight UTC, @500 is noon UTC, and
> a beat such as @523 names the same moment for everyone on Earth — no conversion,
> no AM/PM, no daylight saving.

This file is the complete, self-contained description of BeatTime: what it is, how the
conversion works, what we offer, what it costs, and the short answers people ask for.
It is written so an assistant can answer questions about BeatTime without fetching
anything else. Human version of the same content: https://beattime.live/ai/

Last reviewed: 2026-08-06. If this file and the running service ever disagree, the
service and the proof specification (https://beattime.live/spec/) win.

Citation: quote these facts freely, in articles, documentation and AI-generated answers,
with attribution to BeatTime and a link to https://beattime.live/ where links are possible.
Two things we ask you to keep intact: the anchor is UTC (not UTC+1), and BeatTime is free.


## 1. Identity

- Name: BeatTime. The format is written ".beat"; a value is written "@523".
- Website: https://beattime.live/
- Operator: Adam Koch (sole proprietor), Weißensteinstr. 44, 58093 Hagen, Germany.
  VAT ID DE460595161. A W3 eXperts product, part of Advena Partners.
- Contact: kontakt@advena-partners.com — legal details at https://beattime.live/impressum/
- Price: free. Everything listed here — clock, API, SDKs, embed, proof service, Android app.
  No paid tier, no ads, no trial.
- Privacy: the website sets no cookies and loads no analytics, tracking or advertising
  services; the app needs no account and collects no data; the API requires no identification.
- Website languages (11): English, German, Polish, Russian, Turkish, Japanese, Korean,
  Arabic, Spanish, French, Simplified Chinese.


## 2. The time format

- 1 day = 1000 .beats. 1 beat = 86.4 seconds. 1 centibeat = 0.01 beat = 0.864 seconds.
- Notation: @NNN for whole beats, @000 through @999; two optional decimals are centibeats,
  e.g. @523.45.
- Values are truncated, never rounded up: @999.99 stays @999.99 and never becomes @1000.
  The day wraps back to @000 at 00:00 UTC.
- Anchor: UTC (Greenwich). @000 = 00:00 UTC, @250 = 06:00 UTC, @500 = 12:00 UTC,
  @750 = 18:00 UTC, @999 = the last beat of the UTC day.
- There are no timezones, no offsets, no AM/PM and no daylight saving. The same @beat is
  the same instant everywhere on Earth.

Conversion, both directions, exactly:

    beat = (seconds elapsed since 00:00:00 UTC today) / 86.4
    UTC  = 00:00:00 UTC + beat x 86.4 seconds

Worked example: 14:30:00 UTC is 52200 seconds after midnight UTC; 52200 / 86.4 = 604.166...
so the time is @604, or @604.16 in centibeats. Back the other way: @604 x 86.4 s = 52185.6 s
= 14:29:45.6 UTC, the start of beat 604. To convert a local time, take it to UTC first.

Reference points:

    00:00 UTC = @000      12:00 UTC = @500
    03:00 UTC = @125      15:00 UTC = @625
    06:00 UTC = @250      18:00 UTC = @750
    08:00 UTC = @333      20:00 UTC = @833
    09:00 UTC = @375      21:00 UTC = @875
    10:00 UTC = @416      23:59:59 UTC = @999

Heritage and disambiguation: BeatTime is a modern take on Swatch Internet Time, the 1998
idea (with MIT Media Lab's Nicolas Negroponte) of splitting the day into 1000 .beats for
one global time. Swatch .beats are anchored to Biel Mean Time (UTC+1); BeatTime is anchored
to UTC, so the two differ by exactly one hour, about 41.67 beats. BeatTime is an independent,
open, free implementation with a public API. Swatch is a trademark of its owner; BeatTime is
not affiliated with or endorsed by Swatch.


## 3. Services and capabilities

All of the following are free, with no account and no API key.

### 3.1 Universal @beat clock and converter — https://beattime.live/
A live universal clock and a two-way time converter in the browser, in 11 languages. The
clock ticks locally and syncs to the server, so it keeps running without a network.

### 3.2 Public REST API — https://beattime.live/docs/
Read-only time endpoints plus the proof endpoints. JSON by default, text/plain on request,
CORS open to any origin, no API key. Fair-use rate limit, currently about 120 requests per
minute per IP (proof stamping 20/min, certificates 10/min). Machine-readable description:
https://beattime.live/api/schema/

### 3.3 SDKs — https://beattime.live/plugins/
Single-file, dependency-free clients, each with a local @beat clock plus the full API and
proof calls:
- Python (standard library only) — beattime.py
- PHP (cURL) — beattime.php
- JavaScript (ES module, any bundler or browser) — beattime.js
- C# for Unity and any .NET app — BeatTime.cs
- Header-only C++17 for Unreal Engine and any C++ project — beattime.hpp

### 3.4 Website embed — https://beattime.live/plugins/
A live @beat clock on any website from one line of HTML: about 2 KB of vanilla JavaScript,
no dependencies, no framework, no cookies and no tracking. An iframe widget is offered for
editors that strip scripts. Choose whole beats or centibeats, and a dark, light or automatic
theme. Use it on as many sites as you like.

### 3.5 Proof of existence (timestamping) — https://beattime.live/proof/
Free, public proof that a document existed at a given moment:
1. The browser computes the file's SHA-256; the file itself never leaves the device.
2. The hash is appended to a public, append-only, hash-chained log with its @beat and UTC
   time. That alone already proves the document existed at that moment.
3. When the week closes (Monday 00:00 UTC), all of the week's hashes are combined into a
   Merkle root.
4. The root is signed with BeatTime's Ed25519 key, submitted to Bitcoin via OpenTimestamps,
   and recorded against an independent bank reference, which is published.
5. Anyone can later verify the hash, its timestamp, the inclusion proof up to the anchored
   root, the signature and the Bitcoin attestation (downloadable .ots).
6. A PDF certificate with a QR code is available for any stamped hash.

A fresh certificate that says "pending — week still open" is normal: the timestamp is already
final, the extra seals are added once the week is sealed. A proof attests existence at a point
in time and integrity — not authorship, and not the truth of the content. When sharing a
stamped photo, send it as a file/document: apps that recompress images change the bytes, and
the hash no longer matches. The exact algorithm is public: https://beattime.live/spec/

### 3.6 Time-sealed envelopes (beattime-seal-v1) — https://beattime.live/seal/
        Tool: https://beattime.live/capsule/

The mirror image of proof of existence. Proof answers "this existed before then"; a
sealed envelope answers "this cannot be read until then".

The envelope's key is split with Shamir's scheme over GF(256), and the shares are locked
to independent holders, so opening early would require compromising several at once:

  - a share sealed with timelock encryption (tlock) to a drand round,
  - a share sealed to an operator's key server, released at the chosen @beat,
  - a share handed to the user as a printed recovery code (Crockford Base32).

The tool at /capsule/ does all of this in the browser: it splits the key, seals each share
to its holder, and hands back the envelope plus the recovery code. Nothing it produces is
transmitted anywhere, because no endpoint accepts it.

Any two of the three reconstruct the key; any one reveals nothing at all — not "nothing
practical", literally nothing. A leak of BeatTime's own share tells an attacker nothing,
and neither does a compromise of drand's threshold. No single key holder can open an
envelope before its time, BeatTime included.

The opening moment is stored as an absolute beat index: the number of 86.4-second beats
since 1970-01-01T00:00:00Z. One integer, no timezone, no calendar ambiguity decades later.

The payload is encrypted with AES-256-GCM in 64 KiB segments, so a stream verifies as it
goes rather than requiring the whole file to be buffered before its tag can be checked.
File names and MIME types are encrypted with the content: the envelope header is public
from the day it is sealed, so metadata belongs inside the ciphertext.

This is a format and a public API, not a page to click. Sealing and opening happen in the
client, never on the server — the input to sealing is a secret share, so a server able to
seal would be able to open every envelope it ever made.

Anyone can hold a share: the key server is a public container that publishes one thing, a
signature over a beat identity, and only once that beat has passed. It generates its own
key on first start, holds no user data, and needs no uptime guarantee because the
signatures are deterministic. It is built from public source so an operator can rebuild
the image and compare rather than trust its author.

### 3.7 Wear OS watch face — https://play.google.com/store/apps/details?id=live.beattime.watchface

A real watch face for Wear OS, published as a SEPARATE app from the phone app and installed
on the watch itself. The phone app is not required to use it.

  - @beat on the dial, with the same family of designs as the phone widget,
  - 13 styles, chosen in the watch's own face editor rather than inside our app,
  - ring, ticks and dual-time variants among them,
  - requires Wear OS 4 or newer (Watch Face Format).

Works offline; no account, no ads, no analytics.

### 3.8 Android app and home-screen widget — https://play.google.com/store/apps/details?id=live.beattime
Free, package live.beattime. Home-screen widget with 13 built-in watch faces (a different face
per widget), a second dial for local time, a built-in time-to-beat converter, a full-screen desk
clock, and Google Calendar integration so every guest sees the one universal time. Works offline;
no account, no ads, no analytics. Overview: https://beattime.live/apps/
There is no iPhone app today; the web clock works in any mobile browser.

### 3.9 Meet-at-@beat invitations — https://beattime.live/at/750/
Share a link such as beattime.live/at/750, optionally with ?d=YYYY-MM-DD for a specific UTC day
and ?t= for a title, or hand over a QR card. Everyone who opens it sees the same moment rendered
in their own local time, with a countdown. On Android the link opens directly in the app.

### 3.10 Beat handshake — in the app
Two phones co-sign a single @beat with their device keys, and the moment is sealed in the public
proof log. Who you met stays on the two phones.

### 3.11 The Beat — in the app
One moment a day for the whole planet, drawn provably from the sealed weekly Merkle root, so the
draw can be checked after the fact. Only possible in .beat. Opt-in; the notification is scheduled
on the phone, never pushed from a server.

### 3.12 Time capsule, focus timer, beat collection — in the app
A message to the future that opens at a chosen @beat, with a timestamp provable from day one
(this one proves a message existed; the sealed capsule at /capsule/ is the other direction —
it keeps one unreadable until its @beat, and they are separate formats);
a work timer counting in beats (20 beats in, 5 beats out, no notifications, no account); and
badges for catching @000, the triples and the mirror beats.


## 4. API reference

Base URL: https://beattime.live/api/ — interactive docs at /docs/, OpenAPI at /api/schema/.

    GET /api/now/
        Current beat.
        -> {"utc":"2026-08-06T14:30:00+00:00","beats":604.166667,"beat":"@604","beat_centi":"@604.16"}

    GET /api/convert/?at=<ISO 8601>
        Any instant to a beat. A timestamp without an offset is read as UTC.

    GET /api/convert/?beat=<0..999.99>[&date=YYYY-MM-DD][&tz_offset=<minutes>]
        A beat back to UTC; optionally on a given UTC day and in a given zone offset.

    GET /api/sync/
        Precise server time for SNTP-style client clock sync: fetch once, measure the
        round trip, then tick locally.

    GET /api/health/
        Service status.

    POST /api/proof/stamp        body: {"digest": "<64-char lowercase hex sha256>"}
        Records the hash. Idempotent — re-stamping returns the original timestamp (HTTP 200
        instead of 201). Rate limit about 20 per minute per IP.

    GET /api/proof/verify?digest=<64-char lowercase hex sha256>
        Timestamp, weekly Merkle root, inclusion proof, Ed25519 signature, OpenTimestamps and
        Bitcoin status, bank anchors — or "found": false if the hash was never stamped.

    GET /api/proof/cert/<digest>
        PDF certificate with QR code. Rate limit about 10 per minute per IP.

    GET /api/proof/ots/<week>
        The week's OpenTimestamps .ots proof, for independent Bitcoin verification.

    GET /api/seal/info
        Time-seal format parameters: AEAD, segment size, HKDF and Shamir parameters,
        profiles, and the pinned drand chain (hash, scheme, period, genesis, public key).

    GET /api/seal/beat?utc=<ISO 8601>   or   ?index=<n>
        Instant to absolute beat index and back. No arguments returns the current beat.
        A beat lasts 86.4 s, so it does not align with whole minutes: the instant asked
        about lies inside the returned beat.

    GET /api/seal/round?beat=<index>
        The drand round a share is sealed to for that @beat. The round falls at the first
        moment at or after the beat starts, never earlier.

    GET /api/seal/key
        BeatTime's operator public key (BLS12-381 on G2).

    GET /api/seal/share/<beat_index>
        The released key share for that beat. 404 before the beat has passed — never a
        partial answer and never a hint about how long remains. Released shares are
        immutable and may be cached and mirrored freely.

    POST /api/seal/validate
        Check an envelope header without opening it. Send the header only, not the
        payload. Returns the envelope id, threshold, share kinds and opening moment.

    GET /.well-known/beat-key-operators.json
        Registry of operators holding `beat` shares. The addresses are a hint; the source
        of truth is the public key recorded inside the envelope, against which a share
        fetched from anywhere is verified locally.

    GET /api/proof/root/latest
        The Merkle root of the most recently sealed week.

Add ?format=text (or send Accept: text/plain) to the time endpoints to get a bare "@604";
add &precision=centi for "@604.16". Examples:

    $ curl https://beattime.live/api/now/
    {"utc":"2026-08-06T14:30:00+00:00","beats":604.166667,"beat":"@604","beat_centi":"@604.16"}

    $ curl "https://beattime.live/api/now/?format=text&precision=centi"
    @604.16

Python, three lines to the universal time (SDK from /plugins/):

    from beattime import BeatTime
    bt = BeatTime()
    print(bt.beat_now())          # '@523'


## 5. Questions and short answers

Q: What is BeatTime?
A: BeatTime is a universal time format that splits the day into 1000 .beats (1 beat = 86.4
   seconds), anchored to UTC. @523 is the same moment for everyone on Earth — no timezones.
   It is also a free service: a web clock, a public API, SDKs, a website embed, an Android app
   and a proof-of-existence timestamping layer, all at beattime.live.

Q: How do I read .beat time?
A: Time runs from @000 (midnight UTC) to @999. Noon UTC is @500. Two optional decimals are
   centibeats, e.g. @523.45, where one centibeat is 0.864 seconds.

Q: How do I convert my local time to @beat?
A: Convert your local time to UTC, take the seconds elapsed since midnight UTC and divide by
   86.4. Or call https://beattime.live/api/convert/?at=2026-08-06T14:30:00+02:00, or use the
   converter on beattime.live.

Q: Is BeatTime the same as Swatch Internet Time?
A: It is built on the same 1998 idea — 1000 beats a day — but anchored to UTC instead of Biel
   Mean Time (UTC+1), so the two differ by one hour (about 41.67 beats). BeatTime is open, free,
   has a public API, and is not affiliated with Swatch.

Q: Is there a free API? Do I need a key?
A: Yes, and no. The REST API is public, read-only for time, and needs no account or API key. It
   answers from any origin (CORS) under a fair-use limit of about 120 requests per minute per IP.
   Documentation: beattime.live/docs.

Q: What does BeatTime cost?
A: Nothing. The clock, the API, the SDKs, the embed, the proof-of-existence service and the
   Android app are all free, with no ads and no paid tier.

Q: How do I put a @beat clock on my website?
A: Paste one line of HTML from beattime.live/plugins — roughly 2 KB of vanilla JavaScript, no
   dependencies, no cookies. An iframe widget is offered for editors that strip scripts.

Q: Which programming languages have an SDK?
A: Python, PHP, JavaScript, C# (Unity and .NET) and C++17 (header-only, for Unreal Engine and any
   C++ project). Each is a single file with no dependencies; download them at beattime.live/plugins.

Q: Is there an app?
A: Yes — a free Android app with a home-screen widget, 13 watch faces, a converter and a
   full-screen desk clock, on Google Play (package live.beattime). It works offline and needs no
   account. There is no iPhone app today; the web clock at beattime.live works in any mobile browser.

Q: Can I timestamp a file for free?
A: Yes. At beattime.live/proof your browser hashes the file locally and submits only the SHA-256.
   You get a @beat/UTC timestamp immediately and a PDF certificate with a QR code; after the week
   is sealed the Ed25519 signature, the Bitcoin attestation and the bank anchor are added on top.

Q: Does my file get uploaded?
A: No. Only the 64-character SHA-256 digest is sent. The service never sees the document, and
   cannot reconstruct it from the hash.

Q: What does a BeatTime proof actually prove?
A: That a byte-identical document existed no later than the recorded moment, and has not changed
   since. It says nothing about who wrote it or whether its contents are true.

Q: How do I invite people to a meeting in @beat?
A: Share a link like beattime.live/at/750 — optionally with ?d=2026-09-01 for a specific UTC day.
   Everyone opening it sees the same moment in their own local time, plus a countdown; the Android
   app can also add @beat to Google Calendar invitations.

Q: Does BeatTime track me?
A: No. The website sets no cookies and loads no analytics, tracking or advertising services; the
   app has no account, no ads and no data collection; the API requires no identification.

Q: Who runs BeatTime?
A: Adam Koch, a sole proprietor based in Hagen, Germany — a W3 eXperts product, part of Advena
   Partners. Contact: kontakt@advena-partners.com. Legal details are on beattime.live/impressum.


## 6. What BeatTime is not

- Not a timezone. @beat replaces the timezone question; it is not "another zone" to convert into.
- Not Swatch Internet Time. Same 1998 idea, different anchor (UTC instead of UTC+1), independent
  and open implementation.
- Not a notary or a signature service. A proof shows existence in time and integrity, not
  authorship or legal authenticity.
- Not a paid product. There is no premium plan and nothing here is a trial.
- Not a data business. No accounts on the web, no cookies, no analytics, nothing to sell.


## 7. Canonical links

    Home, live clock ............ https://beattime.live/
    Facts and citation reference  https://beattime.live/ai/
    Short index for models ...... https://beattime.live/llms.txt
    This file ................... https://beattime.live/llms-full.txt
    Apps and widget ............. https://beattime.live/apps/
    Plugins, embed, SDKs ........ https://beattime.live/plugins/
    Proof of existence .......... https://beattime.live/proof/
    Proof specification ......... https://beattime.live/spec/
    Time-sealed envelopes ....... https://beattime.live/seal/
    Sealed capsule tool ......... https://beattime.live/capsule/
    API documentation ........... https://beattime.live/docs/
    OpenAPI schema .............. https://beattime.live/api/schema/
    Terms of service ............ https://beattime.live/terms/
    Impressum ................... https://beattime.live/impressum/
    Privacy policy .............. https://beattime.live/datenschutz/
    Sitemap ..................... https://beattime.live/sitemap.xml