STAC Asset Catalog Preflight

Check one supplied STAC 1.1.0 Collection and up to 100 supplied Items in the supported declaration profile. The report checks IDs, membership, links, declared spatial and temporal extents, assets and asset definitions. It does not fetch imagery, URLs or assets; validate asset availability, geometry coordinates or topology; establish license validity, ownership or rights; certify STAC conformance; or assert that supplied Items exhaust the Collection. Unsupported cases produce incomplete reports and cannot be completed deliveries. Complete reports may contain error findings.

Input

For the built-in example, submit:

{"useDemo": true}

Omit catalogJson and omit consent or set it to false in demo mode. For your own data, set useDemo to false, supply catalogJson as the exact original UTF-8 text of an object containing collection and items, and set authorizedNonpersonalNonconfidentialData to true. Submit only authorized, nonpersonal and nonconfidential data. The platform stores input before execution. No confidentiality, retention, deletion, hosting-location or secret-detection guarantee is made.

Read and save your report

Each completed delivery contains one full thirteen-field dataset item. Its reportJson field contains the complete report as a JSON string. Use the run's dataset output to download the raw JSON export. Do not select fields or enable cleaning, flattening or unwinding. Save the downloaded item or single-item array as item.json.

The following complete Python 3 standard-library recipe saves the exact UTF-8 report bytes without reformatting them. Save it as save_report.py, then run:

python3 -B save_report.py item.json report.json

report.json must not already exist. Use a trusted local directory. This recipe checks the report's byte count and SHA-256 against the exported item. It does not validate the full public consistency policy, prove sender authenticity, or prove that the report accurately represents the original input. A sender who changes the report can also change its hash. Review the report before sharing it.

import hashlib
import json
import os
import stat
import sys


def unique_pairs(pairs):
    result = {}
    for key, value in pairs:
        if key in result:
            raise ValueError("Duplicate JSON key")
        result[key] = value
    return result


def reject_constant(value):
    raise ValueError("Non-finite JSON number")


def main():
    if len(sys.argv) != 3:
        raise ValueError("Usage: save_report.py item.json new-report.json")
    with open(sys.argv[1], "rb") as source:
        if not stat.S_ISREG(os.fstat(source.fileno()).st_mode):
            raise ValueError("Input must be a regular file")
        raw = source.read(8_000_001)
    if len(raw) > 8_000_000:
        raise ValueError("Export exceeds 8 MB; use a single complete item")
    item = json.loads(raw.decode("utf-8"), object_pairs_hook=unique_pairs,
                      parse_constant=reject_constant)
    if type(item) is list:
        if len(item) != 1:
            raise ValueError("Expected exactly one item")
        item = item[0]
    if type(item) is not dict or type(item.get("reportJson")) is not str:
        raise ValueError("Missing reportJson string")
    report = item["reportJson"].encode("utf-8")
    if not 1 <= len(report) <= 4_194_304:
        raise ValueError("Invalid report size")
    if type(item.get("reportBytes")) is not int or item["reportBytes"] != len(report):
        raise ValueError("Report byte count mismatch")
    if type(item.get("reportSha256")) is not str or hashlib.sha256(report).hexdigest() != item["reportSha256"]:
        raise ValueError("Report SHA-256 mismatch")
    json.loads(report.decode("utf-8"), object_pairs_hook=unique_pairs,
               parse_constant=reject_constant)
    with open(sys.argv[2], "xb") as output:
        output.write(report)


if __name__ == "__main__":
    try:
        main()
    except (OSError, ValueError, TypeError, RecursionError) as error:
        print("Report not saved: " + str(error), file=sys.stderr)
        raise SystemExit(2)

A separate four-file buyer helper provides additional source-free consistency checks. It is optional; the recipe above needs no helper download. Neither approach proves original-source truth or sender authenticity.

Limits and uncertain outcomes

Raw input is at most 2 MiB. The report is at most 4 MiB and must also satisfy 4 + inputBytes + reportBytes <= 4,500,000. The escaped full delivery must fit within 4,500,000 bytes. Nothing is truncated. Execution uses a 10-second private-worker deadline and a 50-second outer deadline.

Each completed report costs USD 0.10, including platform usage and reports with findings. A receipt describes the expected identity of the completion event; it is not a payment confirmation or proof of configured billing, a charge or settlement. Check the platform's displayed price and spending limit before running. If a run times out, exits with code 124, or reports an uncertain delivery, inspect its existing dataset and charges before taking any further action. An append may already have succeeded or been billed. Do not automatically repost or rerun it.