Screenshot API for Legal Evidence

When people think about screenshot APIs, the first use cases that come to mind are practical and commercial: capturing product pages for price monitoring, generating social media previews, archiving competitor websites, turning HTML templates into images. Day-to-day automation stuff.

But there's another angle that comes up more often than you'd expect: screenshots as legal evidence. A brand finds counterfeit products on a marketplace and needs proof before the listing disappears. Terms of service change overnight, and someone wants to show what the old version said. Then a social media post gets deleted an hour after someone flags it for defamation. In each of these situations, the screenshot is the evidence. And if it can't be verified, it's not worth much.

ScreenshotRun has a parameter for this: certified=true. Add it to any capture request, and the response comes back with a cryptographic hash of the image, a precise timestamp in ISO 8601 format, and a fingerprint of every capture parameter you used. That's the difference between "here's a screenshot I saved" and "here's a screenshot with a verifiable proof chain showing it hasn't been altered since capture." Below, we'll cover how this works in practice and which legal workflows benefit from it.

The problem with regular screenshots as evidence

Open Chrome, press the screenshot shortcut, save the file. You now have a PNG on your desktop. It has a file creation date that your operating system will happily change if you copy it to another folder. There's no record of which URL was loaded. No proof you didn't edit the page in DevTools before capturing. No independent timestamp from a system that wasn't your laptop.

For internal records, that's fine. For anything that might end up in a legal dispute, it falls apart fast. The other side can always ask: how do we know this screenshot is real? When exactly was it taken? Who says it hasn't been modified?

Dedicated forensic tools exist for this. I looked into Page Vault pricing when a client asked about evidence-grade captures: $149-$199 per on-demand capture, or monthly seat licenses in the same range. TrueScreen charges up to 2.50 EUR per certification. For one screenshot in a major lawsuit, that's nothing. For a brand protection team monitoring hundreds of marketplace listings, it gets expensive fast.

Capturing legal evidence with the certified parameter

Add certified=true to your API request. Everything else stays the same: you pass the URL, pick your format, set viewport options, whatever you need. The only difference is what comes back in the response.

curl "https://api.screenshotrun.com/v1/screenshots/capture?\
url=https://example.com/disputed-page\
&certified=true\
&full_page=true\
&response_type=json" \
  -H "Authorization: Bearer YOUR_API_KEY"

The JSON response includes a certification object alongside the usual screenshot data:

{
  "certification": {
    "sha256": "7b3f8a1c92d4e6b5...",
    "captured_at": "2026-10-16T11:47:33+00:00",
    "url": "https://example.com/disputed-page",
    "options_hash": "c4a8e2f17b3d9065...",
    "file_size": 341280,
    "screenshot_id": "e5f6g7h8-..."
  }
}

That sha256 field locks the image contents at the moment of capture. Anyone can verify it independently: take the downloaded file, pipe it through sha256sum screenshot.png, and check if the output matches the API response. A match means nothing was touched. Even a one-pixel crop would produce a completely unrelated hash string. The options_hash is a separate fingerprint covering the URL and every parameter you passed, tying the image to a specific page and capture configuration. For the full breakdown of each certification field and the verification workflow, see the certified screenshot feature page.

Legal screenshot API use cases

In every case below, something on the web might disappear, and you need proof of what it looked like at that moment.

• Trademark and counterfeit cases. Counterfeit listings disappear fast. A seller gets reported, deletes the listing, creates a new account the next day. If you didn't capture the infringing page before it vanished, your evidence vanished with it. WIPO handles thousands of domain-name trademark disputes every year, and each one needs documented proof of bad-faith use. A script that captures 500 marketplace pages overnight, each with a hash and timestamp, costs under $5 in API credits. When you file the DMCA takedown or UDRP complaint months later, the evidence is already there.

• What about deleted social media posts? Defamatory posts get deleted. Sometimes within hours of a cease-and-desist letter, sometimes as soon as the poster realizes there might be consequences. A phone screenshot proves nothing about when it was taken or whether the content was real. Certified captures preserve the full page: the post, the username, the timestamp, engagement metrics, the surrounding thread. The hash locks all of it at the moment of capture.

• Company changes their pricing page after a customer signs up based on the old terms. Company says the new terms always applied. Scheduled weekly captures of your own terms and pricing pages (or your vendor's) build a timeline automatically. When a terms of service or pricing dispute comes up, you pull the certified screenshot from the relevant week. No scrambling, no "I think it said this."

• Insurance investigations. An injury claimant says they can't work, but their public social media shows vacation photos from last weekend. The investigator needs to capture that page before it gets deleted or set to private. A certified capture with hash verification stands on its own without someone having to testify about when and how the screenshot was taken.

• Financial firms, healthcare companies, pharmaceutical advertisers — industries where regulators expect verifiable proof of what was published online. Certified API captures fit naturally into compliance archiving workflows: each image paired with a hash and timestamp. For scheduled compliance workflows, there's a detailed guide on website compliance monitoring.

What courts look for in digital evidence

I won't turn this into a legal textbook, but a few things are worth knowing if you're capturing screenshots for potential legal use.

Courts generally want to see that digital evidence is authentic (it came from where you say it came from), that it hasn't been tampered with (integrity), and that there's some record of how it was handled between capture and courtroom. Three boxes to check. In the US, the Federal Rules of Evidence cover authentication requirements. In the EU, the eIDAS regulation sets standards for electronic timestamps, and qualified timestamps from approved providers carry a legal presumption of accuracy across all member states.

A certified API screenshot checks two of those boxes well: the hash proves integrity, and the timestamp documents when the capture happened. The automated, repeatable nature of an API call also helps with authentication, because the process is documented and consistent. For most civil disputes, IP cases, and compliance audits, that's strong evidence.

For criminal proceedings or high-stakes international litigation, you'll likely need to supplement API captures with additional verification. An independent archival record from the Wayback Machine, for instance, or an eIDAS-qualified timestamp from a separate EU trust service provider. The API timestamp originates from ScreenshotRun's infrastructure, not from a neutral third-party authority, so it doesn't carry eIDAS qualification on its own.

Batch evidence capture

Single captures are straightforward. The value multiplies when you need evidence across dozens or hundreds of URLs at once.

// Capture 50 infringing product listings with certified evidence
const urls = [
  'https://marketplace.example.com/listing/12345',
  'https://marketplace.example.com/listing/12346',
  // ... 48 more URLs
];

for (const url of urls) {
  const response = await fetch(
    `https://api.screenshotrun.com/v1/screenshots/capture?` +
    `url=${encodeURIComponent(url)}&certified=true&full_page=true&format=png&response_type=json`,
    { headers: { 'Authorization': 'Bearer YOUR_API_KEY' } }
  );

  const data = await response.json();
  // Store the certification object alongside the screenshot
  await saveEvidence(url, data.certification);
}

Each response gives you a screenshot_id for reference and the full certification data your evidence database needs. I've seen brand protection teams run this on 500 marketplace URLs in a single overnight batch. For high-volume workflows, add webhook_url to the request and let ScreenshotRun push results to your server as each capture completes. Your code doesn't need to wait or check back.

The Node.js integration guide covers the full setup for this kind of batch workflow, including error handling and retry logic.

Limitations worth knowing before relying on screenshot evidence

This part's worth being honest about. The SHA-256 hash proves the file hasn't changed since capture. It doesn't prove the page content was genuine at the time. If someone served fake content specifically to the API's IP address (unlikely, but theoretically possible), the hash just proves the fake content was captured faithfully.

The timestamp originates from ScreenshotRun's infrastructure, not from a neutral third-party authority. It's accurate and auditable, but it doesn't carry the legal weight of an RFC 3161 timestamp or eIDAS-qualified seal. For EU proceedings where that qualification matters, you'd chain our capture with a separate qualified timestamp service.

And the API captures what the browser sees. If a page uses client-side A/B testing or personalization, the screenshot shows one variant. Worth documenting which variant you needed if that matters for your case.

For most practical purposes, certified API screenshots handle the evidence requirements that come up in trademark disputes, compliance audits, contract disagreements, and social media preservation. Where the stakes go higher, they're a solid foundation you can build additional verification on top of.

Getting started

Include the certified parameter in your next capture request. Download the result, verify the hash with sha256sum, and you've got an evidence chain. That's a satisfying amount of legal weight from one query parameter.

The certified parameter works on every plan, free tier included. No premium tier required, no per-capture surcharge. Your 200 monthly free screenshots can all be certified if you need them to be.

FAQ#