Input Tester

Validate actor input JSON against any Apify actor's declared input schema before triggering a run. Input Tester is for developers who want to catch bad inputs — missing required fields, wrong types, out-of-range values, invalid enum choices — in seconds rather than minutes, at a fraction of the cost of a failed run.

The actor fetches the target actor's input schema from its latest published build, then validates your test input field by field. It does not run the target actor. Validation is pure schema analysis, completes in seconds, and costs $0.15 — far less than a wasted run. The output includes a pass/fail result, a full error and warning list, and ready-to-paste cURL, Python, and JavaScript API snippets.

What data can you extract?

Why use Actor Input Tester?

Writing input JSON for an Apify actor takes guesswork. You scan the documentation, assemble a JSON object, click Run — and 30 seconds later the run fails with a cryptic type error. You fix it, run again. Repeat. Each failed run charges compute time and eats into your budget.

This actor eliminates that loop. Paste your intended input, point it at any public actor, and get a precise field-by-field validation report in seconds. No run triggered. No compute wasted.

Beyond the immediate debugging use case, this actor fits naturally into CI/CD pipelines and automated testing suites:

• Scheduling — schedule nightly validation runs on your actor catalogue to catch schema drift after code changes
• API access — trigger validation from Python, JavaScript, or any HTTP client inside your deployment pipeline
• Proxy rotation — uses Apify's built-in lightweight infrastructure; no proxies needed for pure metadata calls
• Monitoring — combine with Apify webhooks or Slack alerts to get notified when input validation fails in your automated suite
• Integrations — connect to Zapier, Make, or webhooks to trigger downstream actions when a validation check fails

Features

• Required field validation — checks every field declared in required[] is present, non-null, and non-empty in your test input
• Type checking — validates strings, numbers, integers, booleans, arrays, and objects against the schema type declaration
• Integer vs float discrimination — separately detects when a field expects an integer and receives a float (e.g., 50.5 instead of 50)
• Numeric range validation — checks minimum and maximum constraints on all numeric fields and reports the exact violation
• Enum validation — checks values against the allowed options list for select and dropdown fields; reports the invalid value and the full allowed set
• Unknown field detection — warns about any fields in your test input that do not exist in the schema and will be silently ignored at runtime
• Default value reporting — lists every optional field you omitted and shows exactly what default value the actor will substitute
• Live schema fetch — retrieves the input schema from the actor's latest tagged build via the Apify REST API, so validation reflects the current deployed version
• Actor ID normalisation — accepts both username/actor-name format and raw Apify actor IDs; converts / to ~ automatically for API compatibility
• Code generation — cURL — produces a complete, ready-to-paste curl -X POST command with your validated input pre-filled
• Code generation — Python — produces a complete apify-client Python snippet with your input pre-filled
• Code generation — JavaScript — produces a complete apify-client Node.js snippet with your input pre-filled
• Graceful no-schema handling — if the target actor has no declared input schema, returns a warning and still generates code snippets for the input you provided

Use cases for actor input validation

Pre-run debugging for developers

You have assembled input JSON for an actor and want to verify it before committing credits to a run. Point Input Tester at the actor, paste your JSON, and get a pass/fail report in under 10 seconds. Error messages name the exact field and constraint violated — "Value 500 above maximum 200" — so you fix the right thing first time.

CI/CD pipeline gate

Teams that deploy Apify actors through a CI pipeline can add Input Tester as an automated gate. Before merging a change to an actor's input schema, run Input Tester against your canonical test inputs to verify they still pass. If any required field disappears or a type changes, the gate fails before anything reaches production.

Actor portfolio regression testing

Developers managing a portfolio of actors can schedule Input Tester runs against a catalogue of actor IDs and reference inputs. Any run that returns inputValid: false signals a schema change in the target actor that needs attention, enabling proactive monitoring without running the actors themselves.

Onboarding teams to new actors

When introducing a new actor to a non-technical team, use Input Tester to validate their first few input attempts before they run the actor. The warning messages — showing defaults that will be applied for fields they omitted — teach them how the actor behaves without burning credits on exploratory runs.

SDK integration testing

Before publishing a new actor to the Apify Store, run Input Tester against your own actor's ID with a set of example inputs from your documentation. Confirm the inputs you advertise in your README actually validate against your declared schema.

Automated code snippet generation

Input Tester generates valid cURL, Python, and JavaScript snippets for any input you provide, even when the schema is absent. Use it as a code generation tool when you need quick API call templates for actors you are integrating.

How to validate actor input JSON

1. Find the actor ID — Copy the actor's identifier from the Apify Store URL. Use the format username/actor-name (e.g., ryanclinton/google-maps-email-extractor) or the raw actor ID from the actor's settings page.
2. Prepare your test input — Write the JSON object you intend to pass to the actor. Include all fields you plan to use. It does not need to be complete — omitting optional fields is fine and will generate informational warnings.
3. Run the actor — Click "Start" in the Apify Console. The actor fetches the target's schema and validates your input. The run completes in under 15 seconds.
4. Review the report — Open the Dataset tab. Check inputValid for the pass/fail result, review errors for fields that must be fixed before your real run, and copy the generated code snippet for the language you use.

Input parameters

Input examples

Validate a minimal input with missing required fields:

{
    "targetActorId": "ryanclinton/google-maps-email-extractor",
    "testInput": {
        "maxResults": 25
    }
}

Validate a full input with type errors intentionally included:

{
    "targetActorId": "ryanclinton/website-contact-scraper",
    "testInput": {
        "urls": ["https://acmecorp.com", "https://betaindustries.io"],
        "maxPagesPerDomain": 5.5,
        "extractEmails": true,
        "extractPhones": "yes"
    }
}

Validate a complete, correct input before a production run:

{
    "targetActorId": "ryanclinton/email-pattern-finder",
    "testInput": {
        "domain": "pinnaclesupply.com",
        "testEmails": ["[email protected]", "[email protected]"],
        "maxSearchResults": 20
    }
}

Input tips

• Use the exact slug format — username/actor-name works for any public actor. Raw actor IDs (the long alphanumeric string from the actor's API tab) also work.
• Include fields you plan to omit — omitting optional fields is valid, but including them in testInput with your intended values will catch type errors before they reach a real run.
• Read the warnings, not just errors — warnings show which defaults will be applied. An unexpected default can produce surprising output even when inputValid: true.
• Run before every schema change — if you modify an actor's input_schema.json, test your canonical inputs against the new version before pushing to production.
• Combine with Test Runner — Input Tester validates the shape of your input. Use Actor Test Runner to validate the output your actor produces when that input is actually executed.

Output example

{
    "actorName": "ryanclinton/website-contact-scraper",
    "actorId": "ryanclinton/website-contact-scraper",
    "inputValid": false,
    "errors": [
        {
            "field": "urls",
            "error": "Required field missing"
        },
        {
            "field": "maxPagesPerDomain",
            "error": "Expected integer, got float 5.5"
        },
        {
            "field": "mode",
            "error": "Value \"crawl-all\" not in allowed values: single-page, multi-page, smart"
        }
    ],
    "warnings": [
        {
            "field": "extractEmails",
            "warning": "Not provided — will use default: true"
        },
        {
            "field": "proxyConfig",
            "warning": "Not provided — will use default: {\"useApifyProxy\":true}"
        },
        {
            "field": "unknownFlag",
            "warning": "Field not in input schema — will be ignored"
        }
    ],
    "schemaFound": true,
    "testedFields": 3,
    "schemaFields": 9,
    "generatedCurl": "curl -X POST \"https://api.apify.com/v2/acts/ryanclinton/website-contact-scraper/runs?token=YOUR_TOKEN\" \\\n  -H \"Content-Type: application/json\" \\\n  -d '{\"urls\":[\"https://acmecorp.com\"],\"maxPagesPerDomain\":5}'",
    "generatedPython": "from apify_client import ApifyClient\nclient = ApifyClient(\"YOUR_TOKEN\")\nrun = client.actor(\"ryanclinton/website-contact-scraper\").call(run_input={\n  \"urls\": [\"https://acmecorp.com\"],\n  \"maxPagesPerDomain\": 5\n})",
    "generatedJavascript": "import { ApifyClient } from \"apify-client\";\nconst client = new ApifyClient({ token: \"YOUR_TOKEN\" });\nconst run = await client.actor(\"ryanclinton/website-contact-scraper\").call({\n  \"urls\": [\"https://acmecorp.com\"],\n  \"maxPagesPerDomain\": 5\n});",
    "validatedAt": "2024-11-14T09:22:31.001Z"
}

Output fields

How much does it cost to validate actor input?

Actor Input Tester uses pay-per-event pricing — you pay $0.15 per validation. Platform compute costs are included. The actor fetches schema metadata only and does not run the target actor, so there are no additional compute charges beyond the flat validation fee.

You can set a maximum spending limit per run to control costs. The actor stops when your budget is reached.

Compare this to the cost of a failed run on a data-intensive actor — a 30-second compute run on a 512 MB actor can cost $0.50–2.00 in platform credits before it errors out. Input Tester pays for itself the first time it prevents a wasted run. Apify's free tier includes $5 of monthly credits, enough for 33 validations at no charge.

Validate actor input using the API

Python

from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")

run = client.actor("ryanclinton/actor-input-tester").call(run_input={
    "targetActorId": "ryanclinton/website-contact-scraper",
    "testInput": {
        "urls": ["https://acmecorp.com"],
        "maxPagesPerDomain": 5,
        "extractEmails": True
    }
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    status = "VALID" if item["inputValid"] else "INVALID"
    print(f"Validation result: {status}")
    for err in item.get("errors", []):
        print(f"  ERROR — {err['field']}: {err['error']}")
    for warn in item.get("warnings", []):
        print(f"  WARN  — {warn['field']}: {warn['warning']}")
    print(f"\nGenerated Python snippet:\n{item['generatedPython']}")

JavaScript

import { ApifyClient } from "apify-client";

const client = new ApifyClient({ token: "YOUR_API_TOKEN" });

const run = await client.actor("ryanclinton/actor-input-tester").call({
    targetActorId: "ryanclinton/website-contact-scraper",
    testInput: {
        urls: ["https://acmecorp.com"],
        maxPagesPerDomain: 5,
        extractEmails: true
    }
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
for (const item of items) {
    const status = item.inputValid ? "VALID" : "INVALID";
    console.log(`Validation result: ${status}`);
    for (const err of item.errors) {
        console.log(`  ERROR — ${err.field}: ${err.error}`);
    }
    for (const warn of item.warnings) {
        console.log(`  WARN  — ${warn.field}: ${warn.warning}`);
    }
    console.log(`\nGenerated cURL:\n${item.generatedCurl}`);
}

cURL

# Start the validation run
curl -X POST "https://api.apify.com/v2/acts/ryanclinton~actor-input-tester/runs?token=YOUR_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "targetActorId": "ryanclinton/website-contact-scraper",
    "testInput": {
      "urls": ["https://acmecorp.com"],
      "maxPagesPerDomain": 5,
      "extractEmails": true
    }
  }'

# Fetch results (replace DATASET_ID from the run response)
curl "https://api.apify.com/v2/datasets/DATASET_ID/items?token=YOUR_API_TOKEN&format=json"

How Actor Input Tester works

Phase 1 — Actor schema retrieval

The actor calls GET /v2/acts/{encodedId} on the Apify REST API to retrieve the target actor's metadata. It reads the taggedBuilds.latest.buildId field to identify the current published build, then calls GET /v2/acts/{encodedId}/builds/{buildId} to fetch the full build record. The inputSchema field in the build record is a JSON string; the actor parses it to extract the properties object and the required array. If either call fails or the schema is absent, the actor proceeds to code generation with a warning rather than erroring out. Actor IDs containing / are normalised to ~ before use in API URLs, matching the Apify REST API convention.

Phase 2 — Field-by-field validation

Validation runs in three passes. The first pass iterates required[] and checks that each named field is present in testInput and is neither null nor an empty string. The second pass iterates every key in testInput and applies the following checks against the corresponding schema property: (a) type match — Array.isArray is used to distinguish arrays from objects, and integer fields receive an additional Number.isInteger check to catch float values that would pass a basic number check; (b) range check — minimum and maximum are compared numerically; (c) enum check — the value is compared against the enum array using strict equality. Fields present in testInput but absent from the schema generate a warning rather than an error. The third pass iterates all schema properties and generates warnings for optional fields with declared defaults that were omitted from testInput.

Phase 3 — Code generation

Three code snippets are generated from the targetActorId and testInput values regardless of validation outcome. The cURL snippet uses JSON.stringify to inline the input as a -d payload. The Python snippet formats the input with JSON.stringify(input, null, 2) indentation and wraps it in an apify_client call. The JavaScript snippet does the same for a Node.js apify-client import. All three are included in the output record so you can copy whichever fits your stack.

Phase 4 — Charging

The actor uses the Apify Pay-Per-Event API (Actor.charge({ eventName: 'input-validation' })). One charge of $0.15 is triggered after the validation report is pushed to the dataset. If the spending limit for the run has been reached, a warning is logged and the charge is skipped — the output is always written before charging occurs.

Tips for best results

1. Test your canonical inputs before every deploy. Any time you change an actor's input_schema.json — adding a required field, tightening an enum, adding a numeric range — run Input Tester against your documented example inputs to confirm they still pass.
2. Read warnings as documentation. The default-value warnings are effectively a summary of how the actor will behave for fields you omit. Reviewing them once prevents surprises in production output.
3. Batch related validations into separate runs. Each run validates one input object against one actor. If you need to test three different input configurations, run three separate instances — the $0.45 total cost is far cheaper than one failed production run.
4. Use the generated snippets directly. The cURL, Python, and JavaScript snippets are generated from your validated input. Once the validation passes, the snippet is a production-ready API call with the correct input already embedded.
5. Integrate into a CI step. Call the actor via its API endpoint from a GitHub Actions step or a pre-deploy hook. Parse inputValid from the dataset response. If false, fail the pipeline and print the errors array.
6. Check schemaFound: false results. If an actor has no declared schema, the actor returns schemaFound: false and skips validation. This is not an error — some actors accept freeform input. The code snippets are still generated.
7. Combine with Schema Validator for full coverage. Input Tester validates what goes into an actor. Actor Schema Validator validates what comes out. Use both for end-to-end schema confidence.

Combine with other Apify actors

Limitations

• Only validates schema-declared constraints. Input Tester checks types, ranges, required fields, and enum values. It cannot verify semantic correctness — for example, whether a URL is reachable or whether an API key is valid.
• Validates against the latest tagged build only. If the actor has been modified but not rebuilt, the schema in the latest build may not reflect the current source code.
• No support for nested object schema validation. Properties of type object are checked for type match but their internal properties are not recursively validated against nested schemas.
• No array item validation. Arrays are confirmed to be arrays but their element types are not checked against items schema declarations.
• No allOf / oneOf / anyOf support. JSON Schema composition keywords are not evaluated. Only flat property-level constraints are validated.
• Requires the target actor to be accessible with your token. Private actors are accessible if your token has permission. Public actors work without any special configuration.
• Does not validate actor output. Use Actor Test Runner or Actor Schema Validator to validate what the actor returns.
• No diff between multiple input versions. The actor validates one input per run. To compare two input configurations, run twice and compare the outputs manually.

Integrations

• Zapier — Trigger an input validation run from a Zapier workflow when a new actor input configuration is submitted via a form or spreadsheet
• Make — Add an Input Tester step to a Make scenario before an actor run to gate execution on a valid input
• Google Sheets — Store canonical test inputs in a sheet; trigger validation runs from each row to build a live input validation dashboard
• Apify API — Integrate Input Tester as a step in your own CI/CD pipeline via direct HTTP calls; parse inputValid to gate downstream logic
• Webhooks — Trigger a webhook when inputValid: false to notify your team via Slack or email when an input regression is detected
• LangChain / LlamaIndex — Use the generated code snippets from Input Tester as grounded examples when building LLM agents that need to call Apify actors programmatically

Troubleshooting

• "Actor not found (404)" in the output — The targetActorId format is incorrect or the actor is private and your token does not have access. Confirm the slug using the actor's URL on the Apify Store (e.g., apify.com/ryanclinton/website-contact-scraper → slug is ryanclinton/website-contact-scraper). Raw actor IDs from the API tab also work.
• schemaFound: false even though the actor has an input schema — The actor has not been built or the latest build is in a failed state. Trigger a fresh build from the actor's Source tab, wait for it to complete, then re-run Input Tester.
• inputValid: true but the real run still fails — Input Tester validates declared schema constraints only. The actor may impose additional runtime constraints (e.g., valid API credentials, reachable URLs, business logic checks) that are not expressed in the schema. Review the actor's documentation for runtime requirements.
• All fields showing as warnings for "Field not in input schema" — The actor uses a dynamic or freeform input pattern with no properties declared. The schema exists but has no property definitions. schemaFound: true with all warnings of this type is expected behaviour for freeform-input actors.
• Run exceeds budget before completing — Input Tester charges one $0.15 event per run. If your spending limit is set below $0.15, the run will complete but the charge event will be skipped (logged as a warning). Increase your per-run spending limit to at least $0.20 to ensure consistent behaviour.

Responsible use

• This actor only accesses publicly available actor metadata through the official Apify REST API.
• The actor does not execute the target actor or access any of its stored data.
• No input data you provide is stored beyond the single validation output record in your own dataset.
• For guidance on Apify platform usage policies, see the Apify Terms of Service.

FAQ

How do I validate actor input JSON without running the actor? Point Actor Input Tester at the actor you want to validate — provide its slug (e.g., ryanclinton/website-contact-scraper) and your intended input JSON. The actor fetches the schema, validates your input, and returns a pass/fail report. The target actor is never triggered.

What types of validation errors does Actor Input Tester detect? It detects five categories: missing required fields, type mismatches (string vs number vs boolean vs array vs object), integer vs float violations, numeric values outside declared minimum/maximum ranges, and values that are not in a field's allowed enum list. It also warns about unknown fields and omitted defaults.

How accurate is the actor input validation? Validation is 100% accurate against the declared schema constraints. If the schema says a field must be an integer between 1 and 100, Input Tester will catch any violation of that constraint precisely. It cannot catch constraints that are enforced in the actor's code but not declared in the schema.

How long does an actor input validation run take? Most runs complete in 5–15 seconds. The actor makes two Apify API calls (actor metadata + build details), runs in-memory validation, and writes one output record. There are no web requests to external sites and no crawling.

Can I validate input for any actor on the Apify Store? Yes. Input Tester works with any public actor and any private actor your API token has permission to access. Provide the actor slug in username/actor-name format or the raw actor ID from the API tab.

How is Actor Input Tester different from just reading the input schema documentation? Reading documentation tells you what fields exist. Input Tester actually runs your specific JSON through the schema rules and tells you exactly which fields violate which constraints. It also surfaces defaults you might not have noticed, warns about fields you included that the schema ignores, and generates ready-to-use code snippets from your validated input.

Can I use Actor Input Tester in a CI/CD pipeline? Yes. Call the actor via its REST API endpoint, poll for completion, fetch the dataset, and check inputValid. If false, fail the pipeline step and log the errors array. The Python and JavaScript API examples above show the complete pattern. The actor runs in under 15 seconds, making it practical as a pipeline gate.

What happens if the target actor has no input schema? The actor returns schemaFound: false, inputValid: true, an empty errors array, and a warning on the _schema field explaining that validation was skipped. Code snippets are still generated. This is expected behaviour for actors that accept freeform input.

Can I validate input for my own private actors? Yes. As long as your Apify API token has access to the actor, Input Tester can fetch its schema and validate your input. This is the primary use case for teams building and testing actors during development.

Is it legal to use Actor Input Tester? Yes. The actor calls the official Apify REST API using your own token, reading metadata about actors you have permission to access. It does not scrape any website and does not access third-party data without authorisation.

How do I use the generated code snippets? Each output record contains generatedCurl, generatedPython, and generatedJavascript fields. Copy the field for your preferred language and replace YOUR_TOKEN with your Apify API token. The snippet is ready to run — it contains the targetActorId and your testInput already embedded.

Can I schedule Actor Input Tester to run periodically? Yes. Use the Apify scheduler to run Input Tester on a daily or weekly interval with your canonical inputs. If any future schema change breaks your inputs, the scheduled run will return inputValid: false and you can configure a webhook to alert your team.

Help us improve

If you encounter issues, you can help us debug faster by enabling run sharing in your Apify account:

1. Go to Account Settings > Privacy
2. Enable Share runs with public Actor creators

This lets us see your run details when something goes wrong, so we can fix issues faster. Your data is only visible to the actor developer, not publicly.

Support

Found a bug or have a feature request? Open an issue in the Issues tab on this actor's page. For custom solutions or enterprise integrations, reach out through the Apify platform.