HOW TO USE MOON

GUIDES

Step by step: timestamping PDFs and code, keeping receipts provable for decades, signing releases and logs, and using Moon in creative and news work. Each guide says what we have tested.

LEGAL · PDF

TIMESTAMP PDFS

TESTED WITH PYHANKO 0.38

Moon runs a standard RFC 3161 time-stamp authority at https://api.moon369.org/v1/tsa. PDF tools use it to prove when a document, or a signature on it, existed. Only the document's hash is sent.

With pyHanko (tested)

Our helper script does three things: a Moon timestamp on its own, your signature plus a Moon timestamp with long-term validation (PAdES-LTA), and a check.

pip install pyhanko
curl -O https://raw.githubusercontent.com/moon369org/moon-369/main/examples/pdf-timestamp/moon_pdf.py

python3 moon_pdf.py stamp contract.pdf                            # contract-moon.pdf
python3 moon_pdf.py sign contract.pdf --key me.key --cert me.crt  # signed, timestamped, long-term
python3 moon_pdf.py verify contract-moon.pdf
✓ Document timestamp 2026-11-16 06:44:05 · Moon Timestamp Authority

The long-term version embeds Moon's certificate chain and its revocation list inside the PDF, so it can be checked offline decades from now. We tested that it validates from the embedded data alone, with revocation checking required, and that changing one word makes it fail.

Adobe Acrobat

  1. Menu > Preferences > Signatures. Under Document Timestamping, select More.
  2. Time Stamp Servers > New. Name: Moon. URL: https://api.moon369.org/v1/tsa. Set it as the default.
  3. To show Moon timestamps as trusted, add Moon's root certificate: Preferences > Signatures > Identities & Trusted Certificates > More > Trusted Certificates > Import, and allow it for certified documents.

Acrobat follows the same RFC 3161 standard pyHanko does, but we have not run it in Acrobat yet. Moon is not on Adobe's built-in trust list, so other people's Acrobat shows the timestamp as untrusted until they add Moon's root.

LEGAL · CODE SIGNING

SIGN JAVA CODE

TESTED WITH JDK JARSIGNER

A timestamp keeps a signed JAR valid after your signing certificate expires. jarsigner takes Moon as its time-stamp authority:

jarsigner -keystore signer.p12 -tsa https://api.moon369.org/v1/tsa \
  -tsadigestalg SHA-256 -signedjar app-signed.jar app.jar mykey

# check, trusting Moon's root:
keytool -importcert -noprompt -alias moon-root -file moon-root.cer \
  -keystore trust.p12 -storetype PKCS12 -storepass changeit
jarsigner -verify -strict -keystore trust.p12 -storepass changeit app-signed.jar
jar verified.

Without Moon's root, jarsigner still verifies the jar but warns that the timestamp's certificate chain is not trusted.

Windows signtool

signtool sign /fd sha256 /tr https://api.moon369.org/v1/tsa /td sha256 /f cert.pfx app.exe

Not tested yet: we have not run signtool against Moon. Windows does not trust Moon's root by default, so Windows will not show the timestamp as trusted.

LEGAL · CONTRACTS

SNAPSHOT A CONTRACT OR PAGE

Lock the exact wording everyone agreed to: a contract, a terms page, a price list. One script saves the page exactly as served and signs it.

curl -O https://raw.githubusercontent.com/moon369org/moon-369/main/examples/contract-snapshot/snapshot.mjs
node snapshot.mjs https://example.com/terms     # saves the page, signs it, prints the proof link
node snapshot.mjs contract-final.pdf           # or any file you already have

Keep the snapshot file: it is the evidence, and anyone can drop it on moon369.org/verify. No code: Notarize prints a certificate with a QR code. For court, turn the receipt into an evidence pack. A snapshot proves what was received from that address at that moment, not who runs the site.

TRUST

RE-SEAL OLD RECEIPTS

Signatures age. Re-sealing gives a receipt a fresh signature with today's algorithms, so it stays provable even if its original algorithm is broken later. Moon signs a fingerprint of the whole old receipt, signatures included, and logs it on the Tideline.

curl -X POST https://api.moon369.org/v1/reseal \
  -H 'Content-Type: application/json' -d "{\"receipt\": $(cat old.moonmark.json)}" > resealed.json

# later: prove the old receipt existed when it was re-sealed
curl -X POST https://api.moon369.org/v1/reseal/verify -H 'Content-Type: application/json' \
  -d "{\"receipt\": $(jq .receipt resealed.json), \"of\": $(cat old.moonmark.json)}"

The fingerprint is SHA-256 of moonmark-reseal/1, a newline, and the old receipt as JSON with its keys sorted at every level, so anyone can recompute it. Keep both receipts. Re-seal again whenever Moon adds a stronger algorithm. Moon only re-seals receipts that still check out.

DEVELOPERS

SIGN EVERY RELEASE

A GitHub Action signs your release files on Moon and attaches the receipts to the release. It sends fingerprints only.

on:
  release:
    types: [published]
permissions:
  contents: write
jobs:
  sign:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - run: make dist
      - uses: moon369org/moon-369/actions/sign@main
        with:
          files: dist/*
          api-key: ${{ secrets.MOON_KEY }}   # optional, free at moon369.org/api#key
          label: ${{ github.event.release.tag_name }}
          commit: true          # also sign the release commit itself
          upload-to-release: true
          release-notes: true   # add a "Signed on Moon" table to the release notes

Without a key it signs up to 5 files a run. The run's summary lists each file with a link to its proof, and moon-receipts.json holds every receipt. Users check a download at moon369.org/verify. All inputs.

Every commit, as you make it. A git hook has Moon sign each commit's exact git object and keeps the receipt in a git note. Anyone with the repo can recompute the fingerprint with git cat-file commit <sha> | sha256sum.

curl -fsSL https://raw.githubusercontent.com/moon369org/moon-369/main/actions/git-hook/install.sh | sh
git commit -m "Ship it"     # moon: signed 1a2b3c4 at 1928.05.07 07:18:21
git push origin refs/notes/moonmark

It never blocks a commit. How to check a commit.

DEVELOPERS · LOGS

MOONMARKS IN LOGS AND TRACES

A Moonmark sorts as plain text, carries nanoseconds and has no time zone, so logs from many servers line up by sorting. Put it on every log line and span with these attribute names:

ATTRIBUTETYPEMEANING
moon.moonmarkstringThe moment, e.g. 1928.05.06 15:38:57.111285426
moon.unix_nsstringThe same moment in Unix nanoseconds, as a string so no language rounds it
moon.receiptstringOptional: link to a signed Moonmark for this event (an audit seal, a release)
// Node, with the moon369 package (no network calls)
import { moonmark } from 'moon369';
import { trace } from '@opentelemetry/api';

trace.getActiveSpan()?.setAttribute('moon.moonmark', moonmark());

// pino: add it to every line
import pino from 'pino';
const log = pino({ mixin: () => ({ 'moon.moonmark': moonmark() }) });

Moonmarks come from each server's own clock, so they are only as accurate as that clock. Keep NTP running. For proof that a line existed by a certain time, use a signed audit trail.

DEVELOPERS · LOGS

SIGNED AUDIT TRAIL

Two small scripts with no dependencies make any log tamper-evident. Every line is hash-chained, and every minute Moon signs the newest hash. Only that 64-character hash leaves your server.

your-app | node chain.mjs --out audit.jsonl --every 60
node verify.mjs audit.jsonl
10 lines · chain intact · lines 1-10 sealed by Moon at 1928.05.06 15:39:40

Change, remove or reorder a line and verify.mjs names it. Rewrite the whole chain to hide an edit and Moon's signed seals stop matching. We tested all three. Get the scripts.

DEVELOPERS · LOGS

TRACE AN INCIDENT ACROSS SERVERS

  1. Collect. Pull the logs for the window from every server and region, with moon.moonmark on each line.
  2. Merge. Moonmarks sort as text, so one sort gives the timeline across every time zone. For JSON logs: cat */app.log | jq -s -c 'sort_by(."moon.moonmark")[]' > timeline.jsonl, or sort on the field in your log tool.
  3. Mind the clocks. Lines from different servers are only as close as their clocks. Treat events less than your clock error apart (often a few milliseconds) as simultaneous, and use request IDs to order those.
  4. Freeze the evidence. Sign the merged timeline and the raw logs on Moon (POST /v1/sign with each file's SHA-256) before anyone edits them. The receipts show the files you analyzed existed, unchanged, at that moment.
  5. Write it up with Moonmarks for each key event, so readers in any time zone see the same times.
CREATORS

LABEL AI-MADE CONTENT HONESTLY

For image, video and audio generators that want their output trusted:

  1. Say what made it. Write C2PA Content Credentials with digitalSourceType set to trainedAlgorithmicMedia, the IPTC term for AI-generated media. moon369-capture does this when you pass sourceType: SOURCE.ai.
  2. Sign each output on Moon as it is generated, labelled as AI-made. The look-alike hash lets anyone find it later, even after cropping or re-encoding.
  3. Never sign AI output as a camera capture or under a person's name as if they made it by hand.
  4. Let people check. Point users to moon369.org/verify: it shows the Content Credentials and the Moon registration.

Moon proves when something was registered and by whom. It does not detect whether content is AI-made. Honest labels have to come from the tool that made it.

Sign each output in one line. A no-dependency script signs the output and a manifest of the model and prompt fingerprint, so neither can be swapped later.

curl -O https://raw.githubusercontent.com/moon369org/moon-369/main/examples/ai-outputs/sign-output.mjs
node sign-output.mjs image.png --model "my-image-model v2"
your-llm "write a haiku" | node sign-output.mjs --model gpt-x --out haiku.txt

Or paste any answer into moon369.org/sign for a link, QR code and card in one click. The full example.

JOURNALISM

A NEWSROOM WORKFLOW

  1. At capture. Photographers and video teams sign at capture with an app built on moon369-capture, or sign originals on moon369.org as soon as they are offloaded.
  2. Before publishing. Sign the final versions of photos, video, documents and transcripts. Keep the receipts with the story.
  3. With the story. Link the signed Moonmark, so readers can check the image is the one you published, and when.
  4. Incoming material. Run tips and viral media through /verify: it shows whether the file, or anything that looks or sounds like it, was registered earlier and by whom, plus any Content Credentials.
  5. Corrections. If you replace an image, sign the new one. Both receipts stay, so the record shows what changed and when.

An earlier registration is strong evidence of who had a file first, not proof of who made it. Treat it as one source among others.

CREATORS · APPS

GET A C2PA CERTIFICATE

Content Credentials are signed with a claim signing certificate. Validators show them as trusted only if that certificate comes from a certificate authority on the official C2PA Trust List.

  1. Pass the C2PA Conformance Program. Since 1 January 2026 the official Trust List has replaced the interim one, and its CAs issue claim signing certificates only to conforming products. You apply, sign the program agreement and show your app meets the spec. The program issues a conformance record you give to the CA.
  2. Get a certificate from a Trust List CA. SSL.com and DigiCert both issue C2PA claim signing certificates. SSL.com's free tier includes one Level 1 certificate a year for conforming products.
  3. Sign with it. Pass the certificate chain and key to moon369-capture. Keys stay on your server.

Until then, test with your own certificate. Credentials are written and checkable but show as untrusted, and Moon's timestamp and registration still work.

Moon's time-stamp authority is not on the C2PA TSA Trust List yet, so C2PA validators show Moon's timestamp as untrusted unless they add Moon's root. Requirements change often: check c2pa.org and your CA before you plan around them.