Authorized Content Diff

Compare two snapshots you supply, using text-lines-v1 or restricted html-block-v1. This Actor does not fetch pages, monitor sites, execute HTML or JavaScript, repair markup, infer semantic meaning, or determine browser DOM/CSS visibility. Unsupported input is rejected without a partial report. This is a separate product from Business Snapshot.

Try it

The synthetic demo input is {"useDemo":true}. Omit own-input fields in demo mode.

For your own snapshots, set useDemo=false and provide beforeText, afterText, optionsJson, and authorizedNonpersonalNonconfidentialData=true. optionsJson is a JSON string, for example {"profile":"text-lines-v1","ignore_ids":[]}. HTML mode uses {"profile":"html-block-v1","ignore_ids":[]} and accepts only the native restricted fragment grammar. Do not normalize strings. You can enter those fields directly. For local files, save the following optional Python 3 script as make_input.py. It reads exact UTF-8 bytes without newline translation and produces an envelope. It requires only the Python standard library.

"""Create an own-input JSON envelope without changing supplied UTF-8 bytes."""
import argparse,json,sys
from pathlib import Path
p=argparse.ArgumentParser(description=__doc__)
p.add_argument('before');p.add_argument('after');p.add_argument('options')
p.add_argument('--authorized-nonpersonal-nonconfidential-data',action='store_true',required=True)
a=p.parse_args()
values=[Path(n).read_bytes().decode('utf-8') for n in (a.before,a.after,a.options)]
sys.stdout.write(json.dumps(dict(useDemo=False,authorizedNonpersonalNonconfidentialData=True,beforeText=values[0],afterText=values[1],optionsJson=values[2]),ensure_ascii=True,separators=(',',':'))+'\n')

Run:

python3 make_input.py before.txt after.txt options.json --authorized-nonpersonal-nonconfidential-data > INPUT.json

This flag is your confirmation that you may submit these nonpersonal, nonconfidential inputs. Apify stores INPUT before execution. Reports contain supplied text, IDs, spans and hashes. There is no anonymization, secret detection, acquisition-completeness, privacy, deletion, or rights guarantee. Review reports before sharing.

Results and price

A successful delivery places one full item in the default dataset. Fetch the raw dataset items JSON and read reportJson for the canonical report. Each completed report costs USD 0.10, including platform usage and reports with findings. Check the Actor's displayed pricing before running. The receipt describes the expected completion event; it is not proof of configured billing, a charge or settlement. One POST is attempted; uncertain acceptance may be billed and must never be automatically retried. Exit 124 is ambiguous after append: inspect the original run and dataset before deciding what to do.

Save the complete report

Export the default dataset as raw JSON, preserving all fields, and save it as dataset.json in a trusted local directory. Do not use CSV or a field-filtered export. The export should contain one item. Its reportJson string is the full report; no separate helper download is needed.

For an optional local copy, save this standard-library Python 3 script as save_report.py beside dataset.json, then run python3 save_report.py. It refuses to overwrite report.json. This is extraction with a report byte/hash check, not full contract validation, sender authentication, original-input reconstruction or billing verification. Only use an export you intentionally downloaded from your own run. Review the JSON as data; do not execute its contents.

import hashlib, json
from pathlib import Path
raw = Path("dataset.json").read_bytes()
if len(raw) > 4_500_000:
    raise ValueError("Export exceeds supported size")
value = json.loads(raw)
if isinstance(value, list):
    if len(value) != 1:
        raise ValueError("Expected exactly one item")
    value = value[0]
report = value["reportJson"].encode("utf-8")
if len(report) != value["reportBytes"]:
    raise ValueError("Report size mismatch")
if hashlib.sha256(report).hexdigest() != value["reportSha256"]:
    raise ValueError("Report hash mismatch")
with Path("report.json").open("xb") as output:
    output.write(report)

Limits

Each snapshot is bounded at 1 MiB; options at 524,288 bytes. The worker frame is at most 4,500,000 bytes, including a 12-byte header. Report size is at most min(4,194,304, 4,499,988 - beforeBytes - afterBytes - optionsBytes). Escaped singleton POST size is separately capped at 4,500,000 bytes; receipt at 2,048 bytes. Linux per-process address space remains 256 MiB, CPU soft/hard 30/31 seconds, outer wall 50 seconds and worker wall 10 seconds, all lower-only.

The Actor uses 512 MB platform memory with a lower 256 MiB per-process address-space ceiling. Parent and worker share the platform budget. Resource exhaustion can stop a run before a final status is written; inspect the original run and dataset before retrying any uncertain delivery. Only supported isolated Linux runtimes are accepted.

The report uses deterministic exact block/line matching, not semantic similarity or an optimal-edit guarantee. HTML mode is a restricted fragment grammar, not a browser parser. Dataset views are presentation metadata; use raw JSON for the complete report.