Test in production before your users do
ApifyForge Cloud Staging is a pre-publish validation tool that runs your Apify actor in the real cloud environment and validates Docker builds, schema compliance, output quality, and custom assertions — all for $0.50 per staging run. Catches issues that only appear in production: missing dependencies, memory limits, proxy failures, and Docker build errors before they reach users.
Local testing uses Node.js directly while Apify's cloud uses Docker containers. ApifyForge Cloud Staging bridges that gap by running your actor in the same environment your users will see — then validating the output against your declared schema and custom assertions automatically.
Verifies your Dockerfile builds without errors on Apify's infrastructure. Catches missing dependencies, wrong base images, and build script failures that don't appear in local development.
Fetches your actor's declared dataset_schema.json and validates every output field against it. Same checks as ApifyForge Schema Validator, run in the actual cloud environment.
Checks field presence across all output items, type consistency per field, and empty array detection. Catches data quality issues that only appear with real production data.
Set minimum result counts, required fields, and field type constraints. The same assertion engine as ApifyForge Test Runner, applied in the cloud environment.
Verifies the actor completes with SUCCEEDED status. Catches crashes, timeouts, and out-of-memory errors that don't appear when running locally with unlimited resources.
Clear overall result based on run status, schema validation, and all assertion checks. One answer: is this actor ready for production? CI/CD-compatible structured JSON output.
There are several ways to test an Apify actor before publishing. Each trades off speed, coverage, and automation differently.
| Method | Environment | Validation scope | Automation | Cost |
|---|---|---|---|---|
| ApifyForge Cloud Staging | Apify cloud (Docker) | Build + schema + assertions + output quality | Fully automated, CI/CD-compatible | $0.50/run + compute |
| Manual Apify Console run | Apify cloud (Docker) | Run status only — manual output review | Manual, 10-15 minutes per check | Compute cost only |
| Local development testing | Local Node.js (no Docker) | Code logic only — misses Docker/cloud issues | Fast iteration, no cloud validation | Free |
| Apify Store automated test | Apify cloud (post-publish) | Input + run status + dataset + duration | Runs after publish — too late for prevention | Free (but risks maintenance flag) |
ApifyForge Cloud Staging is the only method that validates in the real cloud environment before publishing, combining Docker build verification with output quality checks.
{
"targetActor": "ryanclinton/website-contact-scraper",
"runId": "abc123def456",
"runStatus": "SUCCEEDED",
"runDuration": 8.3,
"results": 1,
"schemaValidation": {
"passed": true,
"errors": 0,
"warnings": 2,
"details": [
"Dataset schema found and validated against output",
"Field 'socialLinks' only present in 1/1 items (100%)"
]
},
"assertions": {
"passed": true,
"checks": [
{ "check": "minResults >= 1", "passed": true, "actual": 1 },
{ "check": "field 'url' exists", "passed": true }
]
},
"overallResult": "PASS"
}Connect your Apify token and enter the actor ID you want to stage
ApifyForge Cloud Staging runs your actor in Apify's cloud and validates build, output, and schema
Get a PASS/FAIL verdict with detailed check results — ready for CI/CD integration
Several approaches exist for testing Apify actors before publishing. The right choice depends on whether you need cloud environment fidelity, output validation, or both.
Run the actor in the Apify Console and manually inspect the output. Catches cloud-specific issues but requires 10-15 minutes of manual review per actor. No automated schema validation or assertions.
Best for: quick one-off checks when you just need to see if it runs.
Run the actor locally with 'apify run' or directly with Node.js. Fast iteration but misses Docker build issues, cloud memory limits, proxy configuration, and network access restrictions. No schema validation.
Best for: rapid code iteration during development before any cloud testing.
Apify's own post-publish quality check that validates input schema, run status, dataset output, and duration under 5 minutes. Runs after publishing — if it fails, your actor gets a maintenance flag visible to all users.
Best for: understanding Store requirements (but run ApifyForge Cloud Staging first to pass it).
Write a custom Node.js or Python script that calls the Apify API, starts a run, and checks the output. Fully customizable but requires 2-4 hours of development and ongoing maintenance. No built-in schema validation.
Best for: teams with existing CI/CD pipelines who want free, fully custom validation.
Automated end-to-end pre-publish validation: Docker build, run status, schema compliance, output quality, and custom assertions in one operation. $0.50 per run with structured JSON output for CI/CD integration. No scripting required.
Best for: developers who want comprehensive pre-publish validation without building custom tooling.
Every staging run executes on your own Apify account at the standard pay-per-event rate of $0.50 per runplus your actor's normal compute cost. The ApifyForge platform itself is free — no subscription, no premium tier. Apify's free plan includes $5/month in credits.
ApifyForge Cloud Staging runs your actor in Apify's real cloud environment and validates six things: Docker build success, run completion with SUCCEEDED status, non-empty dataset output, schema compliance against your declared dataset_schema.json, structural consistency across all output items, and any custom assertions you define (minimum result counts, required fields, field types). It catches issues that only appear in production — different Docker images, network routing, proxy configs, and memory limits.
Each ApifyForge Cloud Staging run costs $0.50, charged as a pay-per-event (PPE) fee on your own Apify account, plus the compute cost of running your actor once. ApifyForge has no platform fee or subscription. Apify's free tier includes $5/month in credits, enough for approximately 10 staging runs per month before compute costs.
Running an actor manually in the Apify Console tells you whether it succeeded, but you still have to check the output yourself. ApifyForge Cloud Staging automates the validation: it checks schema compliance, verifies field presence across all items, enforces type consistency, and runs custom assertions — all in one operation. A manual check takes 10-15 minutes of clicking through output; Cloud Staging takes 30-60 seconds and gives you a PASS/FAIL verdict.
Yes. ApifyForge Cloud Staging outputs structured JSON with a clear PASS/FAIL verdict, making it suitable for integration with GitHub Actions, GitLab CI, or any CI/CD system. Run the staging actor via the Apify API before every publish and fail the pipeline if the verdict is FAIL. This prevents broken actors from reaching the Apify Store.
Local development uses Node.js directly while Apify's cloud uses Docker containers. Common issues only visible in the cloud include: missing npm dependencies not in package.json, wrong Node.js version in the Dockerfile base image, file system path differences between Linux containers and local OS, proxy configuration failures, memory limit exceeded errors (256MB default vs unlimited locally), and network access restrictions. ApifyForge Cloud Staging catches all of these before your users do.
ApifyForge Cloud Staging works with any actor accessible to your Apify API token — your own actors, actors shared with your organization, and public Apify Store actors. It requires the actor to have at least one valid input configuration. Actors without a declared input schema use an empty input by default.
ApifyForge Cloud Staging supports the same assertion engine as the ApifyForge Test Runner: minimum result counts (e.g., at least 5 items), required fields (e.g., 'url' must exist in every item), field type constraints (e.g., 'price' must be a number), and field presence thresholds (e.g., 'email' must be present in at least 80% of items). Assertions are defined as JSON in the input configuration.
ApifyForge Cloud Staging waits for your actor to complete, then runs validation checks. Total time equals your actor's run duration plus 5-10 seconds for validation. Most staging runs complete in under 2 minutes. If your actor exceeds 5 minutes, the staging run will still wait — but you may want to use a smaller test input to keep staging fast.