Prove you wrote it, without giving it away.
This browser’s Pro key was not accepted: the subscription behind it has ended. Renew or subscribe below.
US$2 a month or US$19 a year for Authorship, or US$5 a month or US$48 a year for everything. 7 days free. Stripe takes a card, and nothing is charged if you cancel before they end.
Everything it does
A tamper-evident record of how your writing came to exist, kept as you write, in a file anyone is free to check. Timestamps from an independent authority if you want them, every paste marked, the writing replayed keystroke run by keystroke run, and nothing uploaded: you decide who gets the file.
Before you start: It records only what is written in it: text pasted from Word or Google Docs arrives, and is shown, as a paste. What else it does not do
Compared with Grammarly Authorship.
In brief
- A record kept as you write Every run of typing, every deletion, cut, paste, undo and redo, with its time, in the order it happened; keys are kept as runs, so a 5,000-word essay’s record measured 94 KB, 28 KB in the bundle
- Pastes shown, not hidden Pasted words are kept with the record and marked as pasted; a paragraph you cut and paste back within the same text is recorded as a move, not as text from outside
- Tamper-evident The record is sealed in blocks, each holding the SHA-256 of the one before and of the document after it, so changing, moving or removing a single event breaks every block after it
- Timestamps, if you want them Every few minutes, and when you share, a 32-byte fingerprint of the record goes to an independent time-stamping authority and comes back signed; off until you turn it on, and the words never go
- One file to hand over A
.oauthor bundle: the work as Markdown, HTML, PDF and Word, the record, the timestamps and a summary PDF with a timeline, signed by a key that never leaves your browser
- Free to check, for anyone A teacher, editor or court opens it at /verify-authorship, with no account and no fee, sees every check, replays the writing at the speed they choose, and can print the report
- The writing process, as facts Each session, the pace of typing and the pauses, and each paragraph of the final text with how it arrived and in how many sittings; never a score
- Sources and citations Say where pasted words came from, kept in the record as what you said; cite a source in APA, MLA, Chicago or Harvard as a footnote
- Assignment briefs A teacher issues a brief with a random code, and may give a length and a due date; a work begun from it carries the code, which shows every keystroke in it came after the brief existed, and one brief can have several documents
- Drawings too A drawing sheet with pen, highlighter, eraser, a stroke eraser and shapes, on layers, with a stylus’s pressure; every stroke and every layer’s change in the same kind of record, and pictures brought in marked as brought in
- A desk worth writing at An outline with the words under each heading; the type, the colours, the browser’s spelling check, focus and typewriter scrolling; right-to-left text and input methods, recorded as typing; statistics; Word and OpenDocument drafts brought in as imported; export to Word, PDF or Markdown with the record beside it
- For teachers Briefs from six templates or your own, with a rubric the student sees while writing; on the free checking page, two points of a record compared word by word, the replay worked from the keyboard, a class’s records in one table that sorts and downloads as CSV, facts set out where a figure passes a line said beside it, and your own notes kept in your browser
Why it exists
Students, writers, journalists, translators and designers are now asked to show they did not use AI, often because a detector said they had. Those detectors give a score, not evidence: OpenAI withdrew its own AI text classifier in 2023 because it was not accurate enough, and the companies that sell them say a score should not be the only reason to accuse anyone. Someone wrongly accused has had little to answer with but their word.
The tools that record how a piece was written keep the work, or the record of it, on the company’s own servers and under its account: Grammarly Authorship, GPTZero’s writing replay and a Google Docs version history all work that way, and the company is left as the judge of what the record means. Authorship keeps the record on your device, in a file you own, and anyone can check that file for themselves.
How a record is checked
Nothing about the check depends on trusting Authorship, this site or the author. Anyone can repeat it from the files in the bundle, and the checking page does it in the browser:
- The chain. Each block of the record holds the SHA-256 of the block before it. The page hashes every block again; if any event was changed, moved or taken out, the hashes stop matching from that block on.
- The document. The page replays every event from an empty page. At the end of each block the rebuilt document must have exactly the fingerprint the block recorded, and the last must be the document in the bundle, byte for byte.
- The timestamps. Each token is checked as RFC 3161 says: the authority’s signature, its certificate and the chain of certificates up to a root kept in the page, that each was valid at the time, and that the token is over this record’s fingerprint at that block. A block cannot have been altered after the token over it was made.
- The clock. The author’s device dates each event; the authority dates each timestamp. A block dated after the timestamp over it is reported, so a record written later with its clock set back shows itself.
- The signature. When the bundle is signed, the page checks the device key’s signature over the list of every file’s SHA-256, and shows the key’s fingerprint, which is the same for every work from the same browser.
Open the example on the checking page to see each check pass, and the replay.
What it proves, and what it does not
A record shows how and when a work came to exist on the device that recorded it, and, where there are timestamps, that nothing in it was altered after each one was made.
It cannot prove that no AI was used. Someone could retype text from another source by hand, and a determined forger could script keystrokes to look like typing. What Authorship does is make faking a long, revised, timestamped record costly, because every pause, deletion and session has to be produced in real time, and give an honest author strong evidence. The checking page shows behaviour as facts (“1,240 characters arrived in one paste at 14:02”) and never as a judgement such as “likely AI”. Authorship has no AI in it and does no AI detection.
Without timestamps, a record is kept on the device alone: its blocks check against each other, but somebody with the whole record could rebuild every hash, so it says nothing about when. The checking page says so.
What is sent, and when
| When | What leaves your device |
|---|
| Writing, drawing, replaying, making a bundle | Nothing. The work and its record are kept in this browser’s private storage. |
| A timestamp, only if you turn them on | The SHA-256 of the record’s latest block: 32 bytes, from which nothing about the words can be worked out. It goes to /api/tsa on this site, which passes it to DigiCert’s public authority, or Sectigo’s when DigiCert does not answer; the authority sees this site’s server, not you. No account, no name, no title. |
| Checking a bundle at /verify-authorship | Nothing. The page reads the file in the browser and asks nobody anything. |
What is in a bundle
| File | What it is |
|---|
chain.jsonl | The record: one block a line, each with its events, its time, the SHA-256 of the block before and of the document after it |
reveal.json | The words of pastes, drops, imports, links, footnotes and undo, each under a salted SHA-256 the chain holds, so any of them can be withheld without breaking the chain |
timestamps/ | RFC 3161 tokens, each over the head of the chain at a block |
document/ | The work in its own Markdown, and as HTML, PDF and Word; a drawing as its strokes and as a PNG |
summary.pdf | The figures, the sessions, each paragraph and how it arrived, and a timeline, for reading and printing |
report.html | The same as a page that opens in any browser with no network, with the final text marked by how each passage arrived; for reading, not the check |
manifest.json, manifest.sig, device.json | Every file’s SHA-256, and the device key’s signature over that list with its public half, when you sign |
brief.oabrief | The assignment brief the work was begun from, when it was |
The format is written down in full at the top of oauthor.js, the code the checking page runs, so it can be checked without either.
How big, and how fast
Measured, not estimated, by authorship-core-test.mjs and authorship-test.mjs, which the site’s checks run: a scripted session of 5,010 words typed key by key over two sessions, with slips, deletions, a paste and a paragraph moved, and a key typed into a 5,000-word text in Chrome.
| What | Measured |
|---|
| Keys typed, and the events they became | 27,067 keys, 1,493 events |
The record of 5,010 words (chain.jsonl) | 94 KB, in 168 blocks |
| The same, compressed in the bundle | 28 KB |
| A key in a 5,000-word text, read back and recorded | 3.7 milliseconds (median) |
| Replaying the record to rebuild the text, and checking every block | Byte for byte, all 168 blocks |
Withholding a passage
The words of every paste, drop, import, link and footnote are kept beside the record under a salted fingerprint, not inside it. Before you share, you can withhold any of them: notes pasted in and later deleted, a private source, a link. The chain still checks, every timestamp still checks, and the record still shows when the passage arrived and how long it was. What cannot be checked is the document itself between the moment those words arrived and the moment they were gone, because rebuilding it needs them; the checking page says exactly which blocks that covers. Withholding words that are still in the final text hides nothing, and Share says so beside each one.
For teachers and editors
Checking is free and always will be: /verify-authorship is a viewer, like a PDF reader, and cannot make a record. Choose the .oauthor file a student or writer gave you; the page checks it and replays it, and nothing leaves your computer.
With Authorship you can also issue an assignment brief: its words, your name, and a code of 128 random bits, timestamped as it is made if you like. A student who begins from the brief carries its code into the first block of their record. Since nobody could have known the code before the brief was made, every event in the record came after the brief; the checking page shows the brief and its time. It is a file you hand out however you hand things out: nothing is published anywhere.
Code and vector drawings
In OBSCURA Umbra, choose Record how this was written in a project’s menu. From then on every edit to every file is recorded, by the same recorder and signed by the same device key: runs of typing, deletions, the editor’s own changes such as formatting, each paste with where it came from (outside the project, or copied from which of its files), each file added, renamed or deleted, and each run with the SHA-256 of the project as it was run and whether it finished or failed. A change made outside the editor, by git or another program, is recorded as that. Save the authorship record writes a .oauthor bundle with the code inside it, to hand in with the work.
The checking page replays it file by file, compares two points one file at a time, and lists every run. A class’s bundles chosen together sit in the same table, with facts for code set against stated lines: how much of the code added was typed, the largest single paste, lines written for the time at work, and how much of the final code was there at the first run. It is free to check, as every record is.
In OBSCURA Vector, File, Record how this was drawn does the same for a drawing: each operation in its history, each undo and redo, each SVG pasted from another program and each picture placed. The checking page replays it as pictures, the drawing’s SVG at each point, and sets two points side by side.
What it cannot do yet
Said now, so that nobody pays to find out.
- Code is recorded in Umbra, and vector drawings in Vector. Code written in another editor and brought in arrives as a file from outside, and is shown as one. Vector records each operation in its history, so a drag is one step, not the path of the pointer. Neither bundle has timestamps yet, and nothing in them can be withheld.
- It records only what is written in it. Work written in Word or Google Docs and pasted in arrives as a paste, and is shown as one. A draft can be imported, and is marked as imported.
- No tables, pictures or comments in a text. Headings, paragraphs, lists, quotations, bold, italic, links and footnotes. Pictures go in a drawing.
- The Photo Editor is not recorded. The drawing sheet is Authorship’s own, with layers of its own. Recording every operation of the Photo Editor faithfully is a larger piece of work.
- No grading, and no AI detection. A rubric is shown, never applied. The checking page sets out counts and times past lines it names; it does not score a record or say whether AI was used.
- No Content Credentials (C2PA) yet. Writing them correctly needs a signing certificate on a trust list and a vetted library to write them; until both are in place Authorship does not write them rather than write them badly.
- Revocation is not checked. The checking page asks nobody anything, so it cannot ask an authority whether its certificate was later revoked. It checks the certificates were valid when the token was made.
- One device per work. A work is kept in the browser it was begun in. A bundle can be made at any time and kept anywhere.
