Creator Campaign Brief

Assemble your supplied adult professional creator evidence into a source-linked HTML brief, CSV roster and complete JSON record for human review. No scraping, enrichment, creator discovery or suitability verification.

Start with the fixed fictional demo, or supply evidence in the exact contract below. The runtime requires a USD 0.10 charge per accepted complete report item, including the demo. Check the displayed price before starting. Use 512 MiB memory, a 60-second timeout, restart Off and a USD 0.11 maximum total charge. Download the one dataset JSON item, then use the standalone extraction example below to recover the HTML, CSV and JSON files.

What it does

Turn your supplied adult professional creator evidence and supplied editorial judgments into a source-linked HTML brief, CSV roster and complete JSON record. The tool assembles evidence deterministically. It does not discover creators, scrape profiles, enrich data, contact people, rank creators, verify source truth or certify suitability.

Each creator receives one exact status:

• shortlist_for_human_review: every supplied required criterion is met and the exact creator ID is not in the supplied existing list
• needs_review: a required criterion is unknown, or there are no required criteria
• excluded: a required criterion is not met or the exact ID is already in the existing list

These are supplied judgments for human review, not recommendations or endorsements. Missing checks remain unknown. Audience demographics, authenticity, brand safety, engagement quality, availability, prices and expected performance are unassessed. Exact case-sensitive IDs are used; there is no cross-platform identity resolution. See INPUT-CONTRACT.md for the unchanged evidence contract.

Fixed fictional demo and optional local evaluation

Python 3.12 on Linux is the tested environment. Runtime uses only the standard library. No credentials, network request or install is required for this local command:

python3 -B actor_adapter.py --input examples/actor-input.synthetic.json --output my-new-bundle

The output directory must not exist, and its parent must exist. The local bundle contains brief.html, shortlist.csv, report.json and OUTPUT.json. Local mode creates no dataset receipt and charges nothing. Use a trusted regular input file and trusted parent directories; final-component symlinks and non-regular input files are rejected. Local files are private to the current POSIX user, subject to filesystem/parent security.

The default input is {"useDemo":true,"authorizedAdultProfessionalData":false}. It always uses the fixed fictional three-profile fixture. Empty or absent evidenceJson is allowed; any nonempty replacement in demo mode rejects. Demo mode never infers permission to use real data. The hosted demo uses the same paid completion mechanism as other reports.

Your own supplied evidence

Set useDemo to false, set authorizedAdultProfessionalData to true, and put the exact evidence JSON text in evidenceJson. A synthetic own-data example is included for local review. Do not upload real records until you have confirmed all source rights, permitted use, recipients, storage visibility and retention.

Only non-confidential adult professional/business campaign evidence may be supplied. Do not include minors' information, credentials, private contact databases, health/financial information or sensitive-trait inferences. Do not supply signed, token-bearing, private or confidential links. A declaration is not verified permission. The parser does not automatically detect secrets or establish that a hostname is public. Geography/language evidence concerns explicitly stated professional coverage or content, never inferred audience attributes.

The engine never fetches profile/source URLs. Generated HTML contains escaped, user-clickable source links, no script, iframe, tracker or third-party asset. Clicking a link leaves the report and can contact that site; reachability and safety are not verified. Do not embed the report into a less restrictive host without your own review. CSV formula-like cells are text-neutralized, but every spreadsheet/import application has its own behavior. JSON preserves evidence literally and must be treated as untrusted data by downstream systems.

Copyable own-data-mode API example (still fictional)

This is a complete input envelope. evidenceJson is a JSON string, not a nested object. It demonstrates the exact accepted fields using fictional evidence; it is not permission to substitute real personal data.

{
  "useDemo": false,
  "authorizedAdultProfessionalData": true,
  "evidenceJson": "{\"schemaVersion\":\"1\",\"rightsDeclaration\":\"Fictional adult professional demonstration; no real person.\",\"campaign\":{\"campaignId\":\"SYNTH_API_CAMPAIGN\",\"title\":\"Fictional campaign\",\"brief\":\"Review supplied topic evidence.\",\"asOf\":\"2026-10-14T12:00:00Z\",\"criteria\":[{\"criterionId\":\"topic\",\"label\":\"Supplied example topic\",\"required\":true}],\"existingCreatorIds\":[]},\"creators\":[{\"creatorId\":\"SYNTH_API_CREATOR\",\"displayName\":\"Fictional Professional Creator\",\"profileUrl\":\"https://example.com/synthetic-profile\",\"observations\":[{\"observationId\":\"SYNTH_OBS\",\"field\":\"topic\",\"value\":\"Fictional supplied example topic.\",\"sourceUrl\":\"https://example.com/synthetic-evidence\",\"observedAt\":\"2026-10-13T12:00:00Z\",\"sourceKind\":\"customer_export\",\"locator\":\"Synthetic export row 1\"}],\"criteriaChecks\":[{\"criterionId\":\"topic\",\"status\":\"met\",\"sourceObservationIds\":[\"SYNTH_OBS\"],\"reason\":\"Fictional supplied editorial judgment.\"}]}]}"
}

Inside evidenceJson, schemaVersion is the string "1". Top-level keys are exactly schemaVersion, rightsDeclaration, campaign and creators. Campaign requires campaignId, title, brief, asOf, criteria and existingCreatorIds. Every creator requires creatorId, displayName, profileUrl, observations and criteriaChecks. Every criterion requires criterionId, label and required. Each observation requires observationId, field, value, sourceUrl, observedAt, sourceKind and locator; publishedAt is optional. Each check requires criterionId, status, sourceObservationIds and reason. No other fields are accepted.

Observation fields are topic, language, geography, activity, format or editorial_note. sourceKind is customer_export or permitted_editorial; neither is verified permission. Check status is met, not_met or unknown. Met/not_met requires at least one observation ID on that same creator. Omitted checks become unknown. IDs must be unique exact strings without whitespace (maximum 128 characters). Names/title maximum 250, criterion labels/locators 500, observation values/rights declaration 2,000, check reasons 1,000 and campaign brief 4,000 characters. Source URLs maximum 2,048 characters, credential-free HTTPS with default/443 port; syntax validation does not identify all sensitive query strings or private hosts. Timestamps require full seconds and Z or an explicit offset within ±14:00; observations cannot follow campaign asOf, and publishedAt cannot follow observedAt.

Bounds

• Exact evidence text: at most 2,000,000 UTF-8 bytes, unchanged from the core
• Envelope: at most 12,100,000 bytes, allowing JSON string escaping of the bounded evidence text; this does not increase the evidence limit
• At most 150 creators, 20 criteria, 30 observations per creator and 5,000 existing exact IDs
• All four generated local artifacts combined: at most 12,000,000 bytes, including the manifest
• Hosted delivery: the single serialized full-output request, including array delimiters and conservative ASCII escaping, must also fit 4,500,000 bytes. Valid evidence within the creator/input limits can exceed this tighter delivery bound and be rejected before any output write. It is never split into multiple billable items
• Malformed/duplicate-key JSON, unsupported fields/types, broken evidence references, invalid timestamps, excessive nesting, non-finite constants and over-limit records reject

The local process also sets a 50-second wall timer, 30-second CPU soft limit and 448 MiB address-space limit. These limits are Linux-specific; no universal worst-case performance guarantee is made.

Required run settings and billing contract

The runtime rejects settings or prices outside this contract. Check the actual displayed price and run options before starting:

• Limited permissions; memory exactly 512 MiB; run timeout at most 60 seconds; restart Off; Standby disabled
• Fresh run-default KVS and dataset, one writer, no shared storage, retries, resurrection, migration, reboot or metamorph
• One flat apify-default-dataset-item event at USD 0.10; no startup event, even at zero price; no other events or tiers; usage add-on Off
• Recommended maximum total charge: USD 0.11. Runtime requires a typed cap greater than USD 0.10 and no greater than USD 0.11. A cap exactly equal to USD 0.10 rejects to avoid terminating immediately at the event boundary before readback

The one completion event pays for a saved report, not for a creator, a suitable candidate or a guaranteed result. A valid zero-creator report, an all-excluded report and an all-needs-review report each still produce one full-output dataset item and would be billable. A rejected input or over-limit full-output item produces no dataset append. A run with no completion can still incur platform compute/storage charges according to actual payer/account terms. The adapter requires DEVELOPER platform-usage billing for customer runs; USER is accepted only when current authenticated run and Actor metadata prove the runner is the exact Actor owner. That owner may pay their own platform usage. The run cap is not a promise about every account/platform charge or net developer costs.

Unknown pricing, payer, lifecycle, identity, storage, resource or standby fields fail closed. Actual billed amounts, refunds, retention, access permissions and terminal run outcomes depend on platform/account behavior; a failed run alone does not establish that no charge occurred.

One complete dataset item per report

The only hosted output write is a single default-dataset POST containing the full report. No generated artifact is written to KVS before or after that append. Raw platform INPUT already exists in KVS as normal. The item contains:

• reportJson: exact core-generated evidence report JSON text
• briefHtml: exact escaped evidence-brief HTML text
• shortlistCsv: exact text-neutralized roster CSV text
• manifestJson: exact prepared-bundle manifest text with all three artifact hashes, byte lengths, source hashes and limitations
• receipt: manifestSha256, reportSha256, inputSha256 and conservative summary counts
• runId and deliveryKey: current authenticated run identity and a deterministic run+manifest reconciliation key

Each field is saved as a string so original artifact bytes can be recovered by UTF-8 encoding. The receipt's manifestSha256 hashes the exact manifest string bytes; reportSha256 hashes exact reportJson bytes; inputSha256 hashes the exact supplied evidence, not the outer Actor envelope. The manifest transitively binds the HTML and CSV. Hashes establish internal byte consistency, not source truth, ownership or signed authenticity. The reconciliation key is evidence for the current run, not a platform deduplication guarantee; rerunning the same input in new storage can charge again.

Before this sole append, authenticated initial/final run/Actor metadata, pricing, the cap and linked empty dataset must pass. The entire serialized request must fit 4,500,000 bytes. Oversized output is rejected before any output mutation. One complete report is one charged dataset item, not one charge per creator, output file or compact receipt. The complete delivered output accompanies the charge event rather than being stored separately beforehand.

Append is attempted once. A lost response, malformed acknowledgment or timeout can occur after the platform accepted the complete item and incurred a charge. No append retry, cleanup or automatic refund follows. Up to four read-only checks within six seconds compare every decoded output string and the exact typed item, allowing ordinary platform JSON reformatting. A failed verification or later terminal run failure does not prove the output was absent or unbilled. Preserve the run ID, dataset and delivery key and reconcile through authorized platform/accounting inspection before considering another run.

The process prints success only after it has read back the exact sole full-output item. Actual terminal run status, event accounting and settled charges remain separate evidence. Single-writer fresh storage is still required; no local check can create a platform transaction or protect against another writer racing it. There is no prior independently readable KVS output, but this implementation cannot guarantee platform billing atomicity or promise that a failed run is free.

Download and extract the HTML, CSV and JSON

In the run's default dataset, export/download JSON with all fields retained. The Actor output link points to that dataset JSON, not to an immediately rendered HTML page. An existing authorized API client can read:

GET https://api.apify.com/v2/datasets/DATASET_ID/items?format=json&clean=false&limit=2

Use the dataset ID returned for that run and your existing authorized client; do not put tokens in links, reports or chat. No new credential creation is needed. Save the JSON array as dataset.json. The delivered HTML/CSV/JSON are strings inside its one item; unescape with a JSON parser, never with text replacement.

Copy and run this standalone Python example against the downloaded export. It requires only Python's standard library and writes REPORT.json, BRIEF.html, SHORTLIST.csv and OUTPUT.json into a new directory. It checks artifact hashes/lengths and report/input binding before writing; it is a concise hash-verification example, not a full schema validator:

import hashlib, json
from pathlib import Path
items = json.loads(Path("dataset.json").read_text(encoding="utf-8"))
if not isinstance(items, list) or len(items) != 1:
    raise ValueError("Expected one complete report item")
item = items[0]
manifest_bytes = item["manifestJson"].encode("utf-8")
manifest = json.loads(manifest_bytes)
receipt = item["receipt"]
sha = lambda data: hashlib.sha256(data).hexdigest()
if sha(manifest_bytes) != receipt["manifestSha256"]:
    raise ValueError("Manifest hash mismatch")
files = {name: item[field].encode("utf-8") for field, name in (
    ("reportJson", "REPORT.json"), ("briefHtml", "BRIEF.html"),
    ("shortlistCsv", "SHORTLIST.csv"))}
for name, data in files.items():
    expected = manifest["artifacts"][name]
    if sha(data) != expected["sha256"] or len(data) != expected["bytes"]:
        raise ValueError("Artifact hash or length mismatch")
if sha(files["REPORT.json"]) != receipt["reportSha256"]:
    raise ValueError("Report hash mismatch")
if json.loads(files["REPORT.json"])["inputSha256"] != receipt["inputSha256"]:
    raise ValueError("Input hash mismatch")
out = Path("extracted-report")
out.mkdir(mode=0o700)  # Must be a new directory.
for name, data in {**files, "OUTPUT.json": manifest_bytes}.items():
    path = out / name
    path.write_bytes(data)
    path.chmod(0o600)

This example never fetches source links or verifies source claims. For untrusted exports, apply bounded input and stricter schema/duplicate-key validation before use. Open BRIEF.html locally only after extraction and your own safety review. Browser/spreadsheet behavior can vary.

Developer-only local QA: the private source package also contains extract_report.py with byte bounds, duplicate-key rejection, typed receipt/count/version checks, no-follow reads and private no-clobber publication, tested using python3 -B extract_report.py dataset.json extracted-report. That private source file is not advertised as a downloadable customer artifact; the standalone example above is the accessible extraction route.

Privacy and limitations

The hosted platform retains raw INPUT, full-output dataset item, run metadata and service logs under its actual account settings. The adapter neither sets permissions nor promises automatic deletion or private-by-ID access. It logs only bounded diagnostic categories and generic status, never supplied evidence, input URLs, tokens or metadata bodies. URLs containing secrets can still leak through your supplied input and generated report; exclusion is your responsibility.

AI-assisted implementation. This README grants no source-code license and establishes no rights to supplied source data. Review source permissions, intended recipients, retention and applicable service terms. Deterministic output and hashes are not security certification, source verification, guaranteed creator suitability or campaign-performance promises.