Disclaimer: This article is for education and for lawful, authorised professional research. Use these methods only where you have a legitimate purpose and a lawful basis, and follow the laws and platform terms that apply to you, including data protection law such as the UK GDPR and EU GDPR. See our Terms of Service.
TL;DR
- To preserve online evidence in OSINT work, a screenshot is not enough. It shows what a page looked like. It does not show where it came from, when it was taken, or that nobody has edited it since.
- Defensible web evidence needs four things: a faithful capture, a SHA-256 fingerprint, an independent timestamp, and a written chain of custody.
- You can do all of it by hand with
sha256sumorGet-FileHash, OpenSSL with an RFC 3161 time-stamping service, OpenTimestamps, the Wayback Machine and WARC tools. We show every command. - UserSearch Forensic Capture, a free browser extension, bundles capture, hashing, two timestamps, a hash-chained notebook and an offline verifier.
- Third-party archives are corroboration, not your primary record. 2024 and 2026 both showed why.
The Screenshot That Did Not Survive Scrutiny
To preserve online evidence for OSINT, you capture the page faithfully, fingerprint it with SHA-256, add an independent timestamp and write a chain of custody note, so any later change is detectable. A fraud analyst finds a marketplace listing offering the exact items reported lost in an insurance claim. She presses Print Screen, pastes the image into the case file and moves on. Six weeks later the listing is gone, the seller account has been renamed, and the other side's lawyer asks three simple questions. Which URL was this? When exactly was it taken? How do we know the image has not been edited?
She cannot answer any of them with confidence. The finding was real. The evidence was weak.
This guide is about closing that gap. We walk through what separates a screenshot from a forensic capture, how to fingerprint and timestamp files so any later change is detectable, how to use public archives and WARC files properly, and how to write the chain of custody note that ties it all together. Most of it can be done with free tools and a terminal.
What Does It Mean to Preserve Online Evidence?
Preservation is the process of capturing online content in a form that can later be shown to be complete, unaltered and correctly attributed to a source and a time. The central idea is chain of custody: a documented, unbroken record of who collected an item, when, how, and everything that happened to it afterwards.
For web content that record rests on four building blocks:
- Capture. A faithful copy of the page: the visible rendering, and ideally the underlying HTML and resources, with the URL.
- Integrity. A cryptographic hash, usually SHA-256, calculated at the moment of capture. Change one pixel or one byte and the hash changes completely.
- Time. A timestamp from an independent source that proves the file, and therefore its hash, existed at or before a given moment.
- Custody. Notes that record the collector, the tools and versions used, storage, and every transfer.
A screenshot gives you a partial version of the first block and none of the others.
Screenshot Versus Forensic Capture at a Glance
| Question a reviewer asks | Plain screenshot | Forensic capture |
|---|---|---|
| Which URL is this? | Only if the address bar happened to be visible | Recorded automatically with the capture |
| When was it taken? | File date, which changes when files are copied | Independent timestamps from outside parties |
| Has it been edited? | No way to tell | SHA-256 fingerprint fails if one byte changes |
| Is the whole page there? | Usually only the visible screen | Full-page capture, often with source code |
| Who handled it? | Whatever someone remembers | Custody notes written at the time |
Screenshots still have a place. They are quick, and they are fine for internal notes and low-stakes checks. The moment a finding might end up in a dispute, a disciplinary hearing, a regulator's file or a published story, capture it properly. You rarely know in advance which findings those will be, which is why many teams simply capture everything that goes into a case file the forensic way.
Why Is Preservation Now a Core OSINT Skill?
Online content is more fragile than most teams assume, and so are the services we use to save it. In October 2024 the Internet Archive was taken offline by a series of attacks. Its services update of 21 October 2024 reported the Wayback Machine back in operation, while uploads and other features were still unavailable. For several weeks, teams who relied on Save Page Now as their only way of preserving pages could not preserve anything.
Reliability is a separate issue from availability. In February 2026, after a discussion involving more than 200 editors, English Wikipedia decided to stop linking to archive.today. Its archive.today guidance cites evidence that the site's operators had altered the content of archived pages, alongside a denial-of-service campaign run through visitors' browsers. An archive that can be edited cannot, on its own, prove what a page said.
archive.today still works, and plenty of researchers still use it as a secondary copy. But after that finding, it should never be the only record of anything that matters.
The lesson is not "never use public archives." It is that your primary record should be one you control, fingerprint and timestamp yourself, with public archives as independent corroboration. That is the reason we built Forensic Capture, and it is how we recommend legal, fraud and compliance teams work.
How Do You Preserve Online Evidence by Hand?
The manual method below uses free tools. It is slower than a dedicated extension, but every step is transparent, and knowing it makes you a better judge of any tool you buy.
Step 1: Capture More Than the Pixels
Before you capture, write down the full URL, the date and time in UTC, and what the page shows. Then capture in at least two forms: a full-page image or PDF, and a copy of the page source. In Chromium browsers, open the developer tools (F12), press Ctrl+Shift+P and run "Capture full size screenshot" to get a full-length image without installing anything. Long pages with lazy-loaded images sometimes come out with blank sections, so scroll to the bottom first. For the source, save the page as "Webpage, Complete" or use the command line:
wget --warc-file=listing-2026-09-24 --page-requisites --adjust-extension --no-verbose "https://shop.example.com/listing/48213"--warc-file writes a standard WARC archive alongside the download, --page-requisites fetches images, CSS and scripts the page needs, --adjust-extension saves HTML with a proper extension, and --no-verbose keeps the log readable. See the GNU Wget manual for the full option list. Friction: wget does not run JavaScript, so modern social platforms often return a near-empty shell. For those, use a browser-based recorder (Step 5).
Step 2: Hash Every File with SHA-256
Hash files immediately after capture, before they are moved or renamed. On Linux, sha256sum is built in:
sha256sum listing-48213.png listing-48213.html > listing-48213.sha256
sha256sum -c listing-48213.sha256The first line writes each file's hash and name to a manifest. The -c flag later re-reads the manifest and reports OK or FAILED for each file. On macOS use shasum -a 256 with the same arguments. For a whole case folder:
find evidence/ -type f ! -name MANIFEST.sha256 -exec sha256sum {} + | sort -k2 > evidence/MANIFEST.sha256find -type f lists every file, ! -name excludes the manifest itself, -exec ... {} + hashes them in batches, and sort -k2 orders the lines by filename so two manifests can be compared with diff.
On Windows, PowerShell's Get-FileHash does the same job:
Get-FileHash -Algorithm SHA256 .\listing-48213.png | Format-List
Get-ChildItem .\evidence -Recurse -File | Get-FileHash -Algorithm SHA256 | Export-Csv .\evidence-manifest.csv -NoTypeInformation-Algorithm SHA256 is the default but worth stating for the record, -Recurse -File walks subfolders and skips directories, and Export-Csv produces a manifest you can attach to the case. Avoid MD5 and SHA-1 for new work; both have known collision attacks.
Step 3: Add an RFC 3161 Timestamp
A hash proves a file has not changed since you hashed it. It does not prove when you hashed it. For that you need a trusted third party. RFC 3161 defines the Time-Stamp Protocol: you send a hash to a Time Stamping Authority, and it returns a signed token binding that hash to its clock. OpenSSL can do this with a free service such as FreeTSA:
openssl ts -query -data evidence/MANIFEST.sha256 -no_nonce -sha512 -cert -out manifest.tsq
curl -H "Content-Type: application/timestamp-query" --data-binary "@manifest.tsq" https://freetsa.org/tsr > manifest.tsr
openssl ts -reply -in manifest.tsr -text
openssl ts -verify -in manifest.tsr -queryfile manifest.tsq -CAfile cacert.pem -untrusted tsa.crt-query -data builds a request from the file's hash, -sha512 sets the hash algorithm, -cert asks the authority to include its certificate, and -no_nonce omits the random nonce, as FreeTSA's own examples do. -reply -text prints the signed time, and -verify checks the token against the authority's CA certificate (cacert.pem) and signing certificate (tsa.crt), both downloaded from the FreeTSA site. Timestamping the manifest covers every file listed in it, which saves one request per file.
Step 4: Add an OpenTimestamps Proof
A second, independent timestamp removes dependence on one authority. OpenTimestamps anchors hashes in the Bitcoin blockchain through public calendar servers. Install the OpenTimestamps client with pip:
pip3 install opentimestamps-client
ots stamp evidence/MANIFEST.sha256
ots upgrade evidence/MANIFEST.sha256.ots
ots verify evidence/MANIFEST.sha256.otsots stamp creates a .ots proof file, ots upgrade (run a few hours later) completes the proof once the calendar's transaction is confirmed, and ots verify checks it. Two points of friction: the proof is pending for hours after stamping, and the client's documentation says full local verification needs access to a Bitcoin node. The web verifier at opentimestamps.org is the practical alternative for most teams.
Step 5: Record a WARC for Dynamic Pages
WARC is the ISO-standard web archive format used by the Internet Archive and national libraries. The WARC 1.1 specification stores every HTTP request and response, so the page can be replayed later, not just viewed as an image. For script-heavy sites, ArchiveWeb.page is a free Chromium extension that records pages as you browse, keeps everything local, and exports WARC or WACZ files you can open in ReplayWeb.page. For larger scheduled crawls, Webrecorder's Browsertrix runs real browsers at scale; the hosted service is paid, and the code is open source.
Step 6: Save an Independent Public Copy
Finally, ask a third party to keep its own copy. The Wayback Machine's Save Page Now accepts a URL directly:
https://web.archive.org/save/https://shop.example.com/listing/48213
curl -s "https://web.archive.org/cdx/search/cdx?url=shop.example.com/listing/48213&output=json&limit=20"The first line saves the page; the second queries the CDX index to list existing captures of that URL, with timestamps and status codes. Expect some platforms to block the archive's crawler, and expect Save Page Now to be slow at busy times. Record the resulting archive URL in your custody notes.
Step 7: Write the Chain of Custody Note
The note is what turns files into evidence. Keep it short, factual and written at the time:
Item ID: CASE-0417-003
Source URL: https://shop.example.com/listing/48213
Captured (UTC): 2026-09-24T09:42:17Z
Captured by: A. Analyst, Claims Review Team
Method/tools: Chromium full-size screenshot; wget 1.21 WARC; sha256sum
Files: listing-48213.png, listing-48213.html, listing-2026-09-24.warc.gz
SHA-256: see MANIFEST.sha256 (RFC 3161 token manifest.tsr; OTS proof)
Public copy: https://web.archive.org/web/20260924094501/https://shop.example.com/listing/48213
Storage: Case share /claims/0417, read-only after 2026-09-24
Transfers: noneRecord transfers as they happen: who received the files, when, and whether the hashes verified on arrival.
Forensic Capture: The Same Steps in One Click
Seven steps and five tools per page is fine for one critical item. It breaks down at twenty items on a busy afternoon, and that is when mistakes happen: a file renamed before hashing, a timestamp forgotten, a URL mistyped.
UserSearch Forensic Capture is a free extension for Chrome, also available for Edge, Brave, Opera and Vivaldi. It runs locally in your browser and does the following:
- Full-page capture of the page you are viewing.
- SHA-256 fingerprints recorded at the moment of capture.
- Two independent timestamps: RFC 3161 and OpenTimestamps, the same pair we used by hand above.
- Cases and a hash-chained notebook, so notes are linked in order and a later edit to an earlier entry is detectable.
- PDF reports for colleagues and clients.
- An evidence bundle with an offline verifier, so a reviewer can check the hashes without contacting us.
Inside the UserSearch 2.0 platform, Cases in Forensic Mode store your search history and bookmarks, so the research that led you to a page is recorded alongside the capture of the page itself.
Advanced Preservation Patterns for Real Cases
Capture the Account as Well as the Post
A post without its author is half the story. Capture the account page too, and record any stable identifier the platform provides in its URL or page source, such as a numeric account ID, because display names and handles can change overnight. Our Reddit research guide shows where those identifiers sit on one major platform.
Prove a Page Changed, Not Just That It Differs
Two captures of the same page will almost always have different hashes, because adverts, timestamps and tokens change on every load. Hashes prove each capture is intact; they do not tell you what changed. Extract the visible text from both captures and compare it with diff, then describe the substantive change in your notes.
Preserve at Scale with One Timestamp
When a case has hundreds of files, build one manifest, timestamp the manifest with both RFC 3161 and OpenTimestamps, and keep the manifest with the files. Any single file can later be checked against its line in the manifest, and the manifest against its timestamps.
Two Worked Preservation Scenarios
Scenario: A Resale Listing in an Insurance Claim
Context. A claims team at a fictional insurer reviews a claim for a lost camera kit. An analyst finds a listing on shop.example.com with matching serial numbers in one photo, posted by @example_handle.
Actions. She captures the listing and the seller's account page with Forensic Capture, adds a notebook entry explaining why the serial numbers matter, and submits the listing URL to Save Page Now. The evidence bundle goes into the claim file.
Outcome. Four days later the listing is deleted. The claim review goes ahead on the preserved capture, whose hashes and timestamps a colleague verifies offline with the bundle's verifier. The claimant later explains the camera was recovered and sold, and the claim is withdrawn.
Scenario: An Altered Review Page for a Legal Team
Context. A law firm acts for a fictional hotel group whose property has been described in an online review on reviews.example.org with false statements about food safety.
Actions. A paralegal follows the manual method: full-size screenshot, an ArchiveWeb.page WARC, a SHA-256 manifest, an RFC 3161 token and an OpenTimestamps proof, plus a Wayback Machine copy. The custody note records each step.
Outcome. After a letter is sent, the review is edited to soften the wording, and the author claims it always read that way. The WARC replays the original text, the timestamps fix it to the capture date, and the independent Wayback copy agrees. The dispute settles.
Legal and Ethical Standards for Captured Evidence
Evidence rules differ by jurisdiction, and nothing here is legal advice. The common thread is that you must be able to show a capture is what you say it is. In the United States, Federal Rule of Evidence 902(14) allows data copied from an electronic file to be self-authenticated by a qualified person's certification, and the advisory committee note names hash values as the usual method. For open source research on serious human rights matters, the UN's Berkeley Protocol sets out international guidance on collection, preservation and verification that any team can borrow from.
- Capture only what the case needs. Pages often include bystanders' names and photos. The ICO's guidance on data minimisation applies to evidence folders too. Redact in reports, not in the original.
- Use only access you are entitled to. Capture public pages, or pages you can see through an account you are authorised to use under the platform's terms.
- Never edit an original. Work on copies, and keep originals read-only with their manifest.
- Set retention. Delete evidence when the matter and any appeal period end, and record the deletion.
Frequently Asked Questions About Preserving Online Evidence
How do you preserve online evidence for OSINT?
Preserving online evidence for OSINT takes four steps: a faithful capture of the page and its source with the URL, a SHA-256 fingerprint calculated at the moment of capture, an independent timestamp such as RFC 3161 or OpenTimestamps, and a written chain of custody note recording the collector, the tools, storage and every transfer.
Is a screenshot enough to preserve online evidence?
A screenshot shows what a page looked like, but it does not show which URL it came from, exactly when it was taken, or that nobody has edited it since. Screenshots are fine for internal notes and low-stakes checks. For findings that might reach a dispute, a regulator or a published story, a forensic capture with hashes and timestamps is stronger.
What is chain of custody for web evidence?
Chain of custody for web evidence is a documented, unbroken record of who collected an item, when, how, and everything that happened to it afterwards. For a web capture, the custody note records the URL, the time in UTC, the collector, the tools and versions used, where files are stored, and each transfer with whether the hashes verified on arrival.
Why is SHA-256 used to hash digital evidence?
SHA-256 is used to hash digital evidence because changing one pixel or one byte of a file changes the hash completely, so any later edit is detectable. A manifest of SHA-256 hashes can be re-checked with sha256sum -c or Get-FileHash. MD5 and SHA-1 should be avoided for new evidence work because both have known collision weaknesses.
What is the difference between RFC 3161 and OpenTimestamps?
RFC 3161 timestamps come from a Time Stamping Authority, which returns a signed token binding a file's hash to its clock. OpenTimestamps anchors hashes in the Bitcoin blockchain through public calendar servers, and its proof stays pending for hours until confirmed. Using both gives two independent timestamps, so the evidence does not depend on a single authority.
Can the Wayback Machine be relied on as evidence?
The Wayback Machine is best used as independent corroboration, not as the only record. In October 2024 the Internet Archive went offline for a period, and some platforms block its crawler. In February 2026 English Wikipedia stopped linking to archive.today over evidence of altered archived pages. The primary record should be a capture you control, hash and timestamp yourself.
Make Every Capture Count
Good preservation is a habit, not a heroic effort. Capture the page and its source, hash immediately, timestamp twice with independent methods, save a public copy, and write the custody note while the facts are fresh. Do that, and the three awkward questions (which URL, when, and has it changed) have clear answers.
If you would rather not run seven steps by hand, install Forensic Capture for free and let it do the capture, hashing and timestamping. Then bring the research itself into UserSearch: one account for 100+ data sources, OneScan to run one identifier across the sources you choose, Cases in Forensic Mode that keep your search history, and SargeBot to draft a PDF report you then check. New to the platform? Our OSINT fundamentals knowledge base is a good first stop.
Stop guessing. Start researching with UserSearch. Open your UserSearch account and keep every finding defensible.