Is this pipeline safe to deploy?
Pipeline Preflight is the pre-deploy CI gate for multi-actor Apify pipelines. It validates that every stage composes before anything runs and returns one reliabilityScore (0-100) plus a routable decisionPosture — ship / canary / monitor / block — your pipeline or agent branches on. $0.40 per build.
Most pipelines fail afterdeploy — not because an actor is broken, but because actors that work alone don't compose: a field is renamed upstream, a mapped field is always null in real data, a saved Task drifts, a per-record stage's cost explodes with volume. Pipeline Preflight catches all of those at definition time, and once you run it on a schedule it remembers which chains work (knownPattern, validRate) and names which actor broke a previously-shippable pipeline. It still generates the orchestration code when the pipeline passes.
Pipeline Preflight doesn't just validate mappings — it decides whether the whole chain is safe to ship.
One 0-100 reliabilityScore and one routable decisionPosture — ship_pipeline / canary_recommended / monitor_only / no_call — backed by pipelineRiskLevel. Branch on decisionPosture in CI or an agent; never parse prose.
A pipeline can pass basic schema checks and still fail in production: a mapped field that's always null in real data, a downstream actor that no longer accepts the payload shape, a saved-Task config that drifted from what you validated. Preflight catches these at definition time.
Flags a per-record pay-per-event stage whose cost scales with upstream volume — the 'validated pipeline, surprise bill' failure. fanoutRisk tells you before you schedule it, not after the invoice.
Run it on a schedule (trackChanges) and it learns your pipelines: pipelineFingerprint, knownPattern, validRate, and commonFailureModes for that exact architecture. sinceLastPreflight flags a regression and schemaChangedActors names which actor broke it — not just that it broke.
Per actor-pair success history (compatibilityConfidence, knownGoodMappings with a per-mapping successRate, knownBadMappings) sharpens the mapping suggestions every run. The longer you run it, the better the suggestions — a corpus a fresh tool can't backfill.
Reads Apify API metadata only — it never calls, runs, or schedules the target actors, so it's safe for CI, cron, and autonomous agents. Get an exit code, a deploy-safe boolean, and a GitHub Actions snippet to wire it into your pipeline.
Checks that output fields from stage N exist in stage N+1's input schema. Catches broken field mappings that would cause silent failures or missing data at runtime.
Flags field mappings where output type doesn't match input type — for example, a string output mapped to an array input. Suggests transformations when possible.
Generates complete orchestration code using the Apify SDK's Actor.call() method with dataset forwarding between stages, error handling, and structured logging.
Sums PPE prices across all pipeline stages for per-run cost projections. Also projects monthly costs at 100 and 1,000 runs for budget planning.
Shows input fields, output fields, PPE price, default memory allocation, and timeout for every stage. Full visibility into what each actor expects and produces.
Fetches input and output schemas from each actor's latest build via the Apify API. Validates against real, current schemas — not assumptions or documentation.
There are several ways to build multi-actor data pipelines on Apify. Each trades off validation depth, code generation, and setup time.
| Method | Field validation | Code generation | Cost |
|---|---|---|---|
| Pipeline Preflight | Automated field + type validation | Complete TypeScript with Actor.call() | $0.40/build |
| Manual Actor.call() coding | Manual schema review | Manual (2-4 hours) | Free (development time) |
| Webhook chaining | No validation | Manual webhook configuration | Free |
| Trial-and-error pipeline testing | Runtime errors only | Manual debugging | Compute cost per failed run |
{
"stages": 3,
"reliabilityScore": 91,
"decisionPosture": "ship_pipeline",
"pipelineRiskLevel": "low",
"fanoutRisk": "low",
"knownPattern": { "seen": 37, "validRate": 0.94 },
"warnings": ["Stage 2: field 'rating' not in Stage 1 output"],
"generatedCode": "import { Actor } from 'apify';\n\nActor.main(async () => {\n const run1 = await Actor.call(...);\n ...\n});",
"costEstimate": { "perRun": 0.45, "monthly100": 45.00, "monthly1000": 450.00 }
}Define your pipeline stages with actor IDs and field mappings
Pipeline Preflight validates field mappings and type compatibility across all stages
Get validated pipeline with generated TypeScript code and cost estimates
Several approaches exist for building multi-actor data pipelines on Apify, from manual coding to webhook chains.
Write TypeScript orchestration code manually by reading each actor's schema, mapping fields, and implementing error handling. Full control but requires 2-4 hours per pipeline and manual schema review with no automated type checking.
Best for: experienced Apify developers building complex pipelines with custom logic.
Configure Apify webhooks to trigger the next actor when the previous one completes. Simple to set up but provides no field mapping validation, no type checking, and limited error handling. Debugging failures requires checking each stage independently.
Best for: simple two-stage pipelines with straightforward data forwarding.
Create multiple Apify tasks and trigger them sequentially via the API or webhooks. More structured than raw webhook chaining but still requires manual field mapping and has no built-in validation or code generation.
Best for: pipelines where each stage uses the same actor with different inputs.
Use established workflow orchestration tools to manage Apify actor pipelines. Powerful but requires significant infrastructure setup, DevOps expertise, and ongoing maintenance. Overkill for most Apify-only pipelines.
Best for: enterprise teams with existing orchestration infrastructure and complex scheduling needs.
Automated pipeline validation with field mapping checks, type mismatch detection, and TypeScript code generation. $0.40 per build. No manual schema review or code writing required — get a validated, runnable pipeline in seconds.
Best for: developers who want validated, working pipeline code without manual schema inspection.
Every pipeline build executes on your own Apify account at the standard pay-per-event rate of $0.40 per build. ApifyForge has no platform fee or subscription. Apify's free plan includes $5/month in credits, enough for about 12 pipeline builds per month.
Pipeline Preflight is a pre-deploy CI gate for multi-actor Apify pipelines. It validates that every stage composes — input/output schemas, field mappings, reachability — before anything runs, and returns one reliabilityScore (0-100) plus a routable decisionPosture: ship_pipeline, canary_recommended, monitor_only, or no_call. It also generates complete TypeScript orchestration code (Actor.call() chains with dataset forwarding) and a per-run/monthly cost estimate. Branch on decisionPosture; never parse prose.
A pipeline can pass basic schema checks and still fail in production. Pipeline Preflight catches the composition failures a naive check misses: a mapped field that's always null in real data, an upstream actor that changed its schema after you scheduled the workflow, a saved-Task config that drifted, and — via fanoutRisk — a per-record pay-per-event stage whose cost explodes with upstream volume (the 'validated pipeline, surprise bill' case). Each rolls into the reliabilityScore and decisionPosture.
Yes, when you run it on a schedule with trackChanges. Every pipeline gets a pipelineFingerprint, and Preflight tracks how often that exact architecture has been seen and what share of runs were valid (knownPattern, validRate, commonFailureModes). sinceLastPreflight flags when a previously-shippable pipeline regresses and schemaChangedActors names which actor broke it. It also keeps per actor-pair compatibility history, so the mapping suggestions sharpen the longer you run it.
Each Pipeline Preflight run costs $0.40, charged as a pay-per-event (PPE) fee on your own Apify account. The tool reads actor schemas from the Apify API — it does not trigger any actor runs. Apify's free tier includes $5/month in credits, enough for about 12 pipeline builds per month.
Pipeline Preflight generates TypeScript code using the Apify SDK's Actor.call() method. The generated code includes proper dataset forwarding between stages, error handling, and logging. You can use it directly in a new Apify actor or adapt it for use in external Node.js/TypeScript applications.
Pipeline Preflight fetches the input and output schemas from each actor's latest build. It checks that output fields from stage N exist as input fields in stage N+1's schema and that their types are compatible. For example, if stage 1 outputs 'urls' as an array but stage 2 expects 'url' as a string, the builder flags both a name mismatch and a type mismatch with a suggested transformation.
Yes. Pipeline Preflight supports pipelines with any number of stages. Each stage-to-stage transition is validated independently. A 5-stage pipeline produces 4 transition validations, each checking field mappings and type compatibility. The generated TypeScript code chains all stages sequentially with proper error handling at each step.
Pipeline Preflight's cost estimate sums the PPE prices across all stages for per-run projections. It also projects monthly costs at 100 and 1,000 runs. Compute costs (memory, duration) are not included in the estimate because they depend on input data size and target site behavior. Use ApifyForge Cost Calculator on each stage actor for compute cost projections.
Yes. Pipeline Preflight reads schemas from any public Apify Store actor. You can mix your own actors with third-party Store actors in the same pipeline. The field mapping validation works the same regardless of actor ownership — it reads the declared input and output schemas from each actor's latest build.
Pipeline Preflight requires actors to have declared input_schema.json and/or dataset_schema.json to perform field mapping validation. Actors without declared schemas are flagged with a warning. You can still build the pipeline, but field mapping validation will be limited to stages where schemas are available. Approximately 15% of Apify Store actors lack output schemas.