Prompt to Apify Task Builder

Convert a structured natural-language task request and actor input schema into a bounded dry-run Apify task configuration with required-field validation.

Use this actor to turn structured task requests or JSON task specifications into a normalized Apify dataset. Each paid row represents one generated Apify task contract; blocked and no-result diagnostics remain free so invalid evidence does not look like successful extraction.

What It Returns

Every dataset row includes stable source and record identifiers, a checked timestamp, current and previous hashes, a change classification, issue codes, a concise recommendation, the charged event name, and strict actor-specific data. The data object contains only fields relevant to generated Apify task contracts.

Change classifications are observed when no prior snapshot is supplied, added for a new key, updated when normalized metadata changed, and unchanged when the normalized record matches. Diagnostic rows use diagnostic, contain no paid event name, and explain how to supply usable evidence.

Input Sources

• Inline currentText, text, or html for deterministic runs.
• items for structured current records and previousItems for structured history.
• previousText for snapshot comparison.
• targets to process several bounded sources in one run.
• urls or sourceUrl only when allowUrlFetch is explicitly enabled.

Public URL retrieval accepts HTTP and HTTPS only. It rejects credentials, redirects, localhost, private and reserved addresses, and DNS results that resolve privately. Responses have timeout and streamed byte limits. Defaults use bounded records from the stated public source and make no network request.

Quick Start

{
  "sourceId": "apify-web-scraper-task",
  "sourceUrl": "https://apify.com/apify/web-scraper",
  "text": "",
  "currentText": "",
  "previousText": "",
  "items": [
    {
      "taskId": "apify-web-scraper-bounded-docs",
      "actorId": "apify~web-scraper",
      "actorSlug": "apify/web-scraper",
      "taskName": "Bounded Apify docs crawl",
      "prompt": "Create a dry-run task input that crawls one public Apify documentation page and limits the crawl to one page.",
      "inputSchema": {
        "type": "object",
        "required": [
          "startUrls",
          "maxCrawlPages"
        ],
        "properties": {
          "startUrls": {
            "type": "array"
          },
          "maxCrawlPages": {
            "type": "integer",
            "default": 1
          }
        }
      },
      "requestedValues": {
        "startUrls": [
          {
            "url": "https://docs.apify.com/"
          }
        ]
      },
      "dryRun": true
    }
  ],
  "maxItems": 1,
  "maxRecordsPerTarget": 5,
  "maxTextBytes": 250000,
  "fetchTimeoutMs": 15000,
  "allowUrlFetch": false,
  "includeDigest": false,
  "includeReport": true,
  "dryRun": false,
  "debug": false
}

Set maxItems to cap source targets, maxRecordsPerTarget to cap normalized records, maxTextBytes to cap each supplied or fetched body, and fetchTimeoutMs to cap public retrieval time. dryRun validates input without charges or dataset output.

Data Quality

The parser normalizes and deduplicates generated Apify task contracts by the actor's stable identity field. It never fabricates missing titles, dates, authors, links, guests, journals, or categories. Missing values stay null or empty and produce explicit issue codes.

Possible issue codes include: missing-actor, missing-task-name, missing-prompt, missing-required-input, missing-endpoint, unsafe-live-mode, source-unavailable. Review warning rows before using them in downstream publishing, outreach, reporting, or alerting.

Reports And Digests

The default key-value store receives a results JSON file, summary JSON, and Markdown report after the corresponding report charge succeeds. Recurring monitor actors also produce JSON and Markdown change digests. Report artifacts are skipped when the run budget cannot cover the report event.

Pay Per Event

Event	Price	Purpose
actor-start	$0.00500	Prompt To Apify Task Builder Actor Start
endpoint-tested	$0.00650	Prompt To Apify Task Builder Endpoint Tested
contract-rule-checked	$0.00390	Prompt To Apify Task Builder Contract Rule Checked
report-generated	$0.05000	Prompt To Apify Task Builder Report Generated

Platform usage is included in these event prices. The actor charges before paid dataset rows or report artifacts are written. If Apify rejects a charge because the run limit is reached, the actor records billing status and stops before the affected paid output.

Operational Guidance

Use stable sourceId values across scheduled runs, retain the prior normalized source snapshot, and compare changes by recordId and changeType. Start with one source and inspect the dataset before increasing limits. Keep URL retrieval disabled when inline or structured evidence is available.

How Parsing Works

This actor accepts structured task requests or JSON task specifications. Structured records take priority when they are supplied. Otherwise, the parser reads the source format directly, normalizes whitespace and identifiers, resolves supported links, removes duplicate identities, and stops at maxRecordsPerTarget.

The actor-specific data fields are: taskId, actorId, actorSlug, taskName, prompt, generatedInput, requiredFields, missingFields, endpointUrl, dryRun, valid. These fields are validated by the strict dataset schema. Unknown top-level output fields and unknown fields inside data are not part of the contract.

Record identity is based on the strongest stable public identifier available for each generated Apify task contract. Links and official IDs are preferred; a deterministic content identity is used only when the source omits a stronger identifier. Reordering a feed or inserting a new record does not turn unchanged historical records into updates.

Comparison Workflow

1. Save the prior source body or structured records after a successful run.
2. Supply that evidence as previousText or previousItems on the next run.
3. Supply the current evidence through currentText, items, or an explicitly enabled public URL.
4. Read added and updated rows as detected events. unchanged rows preserve the current normalized inventory.
5. Store the current source evidence for the following run.

Comparisons use normalized record hashes, not timestamps generated by the actor. This keeps reruns deterministic and prevents a new checkedAt value from creating false changes.

Scheduling And Delivery

For scheduled monitoring, use one stable target per public source and conservative caps. Send alerts from rows whose changeType is added or updated; keep all rows in the dataset when a complete current inventory is required. The JSON summary is suitable for automation, while the Markdown report and optional digest are suitable for review or delivery.

Do not treat an empty paid dataset as a successful zero-change result without checking diagnostics. A blocked diagnostic indicates missing evidence, disabled URL retrieval, an invalid public URL, a private address, a timeout, an oversized response, or an unsupported source shape.

Limits And Failure Handling

• maxItems limits targets before retrieval or analysis.
• maxRecordsPerTarget limits normalized records per target.
• maxTextBytes limits inline and fetched source bodies.
• fetchTimeoutMs limits each explicitly enabled public request.
• Redirects and credentialed URLs are rejected.
• Charge-limit failures stop before the affected paid rows or report artifacts.
• Parser failures produce explicit diagnostics rather than invented records.

Use debug only when investigating source parsing or billing decisions. Avoid logging source bodies that may contain information you do not intend to retain.

Only process public, authorized, or owned sources. Do not use this actor to bypass access controls, collect private data, or make unsupported legal or compliance claims.