Guard Pipeline — Full Lifecycle Quality for Actors

In one sentence

Guard Pipeline is a quality orchestrator on Apify that runs Input Guard, Deploy Guard, and Output Guard in sequence and returns a unified quality report with cross-stage analysis and a weighted score.

Category: Developer Tools. Quality Assurance. Actor Lifecycle Management. Primary use case: Validate an actor across input, deploy, and output stages in one run. Can also be used for regression detection and drift monitoring.

Also known as: actor quality pipeline, actor lifecycle validator, actor quality gate, CI/CD quality check for actors

What this actor does

• What it is: An orchestrator that runs three guard stages (input validation, deploy testing, output monitoring) in sequence against any target actor
• What it checks: Input schema correctness, deploy build health, and output data quality — then cross-references results across stages
• What it returns: A unified report with per-stage scores, a weighted overall score (0-100), cross-stage regression detection, and actionable recommendations
• What it does NOT do: Guard Pipeline does not fix issues it finds. It does not run the target actor in production or modify its code
• Who it's for: Apify developers, actor fleet managers, CI/CD pipeline operators, QA teams managing actor portfolios

Guard Pipeline is an Apify actor that validates any actor across three lifecycle stages — input, deploy, and output — in a single run. It costs $0.25 per pipeline run (sub-actor PPE billed separately), and produces a weighted quality score where input counts for 20%, deploy for 35%, and output for 45%.

Guard Pipeline ties together the three individual Guard actors into one sequential workflow. Instead of running Input Guard, Deploy Guard, and Output Guard separately, Guard Pipeline orchestrates all three, then performs cross-stage analysis that no individual guard can do: escaped regression detection (deploy passed but output failed), input schema change tracking, and deploy-vs-production agreement scoring. The unified report includes aggregated recommendations from all stages and cross-stage feedback loop suggestions.

To validate an actor across its full lifecycle, provide Guard Pipeline with the target actor ID and run it. Guard Pipeline calls Input Guard first, then Deploy Guard, then Output Guard, and returns one report with a weighted score, per-stage breakdowns, and cross-stage findings.

In short: Guard Pipeline runs three quality checks on any actor in sequence and returns one unified report with a weighted score, regression detection, and cross-stage recommendations.

What it is: A sequential orchestrator for the three Guard actors (Input, Deploy, Output) Who it's for: Apify developers managing actor quality across the full lifecycle When to use it: When you need a single quality verdict before deploying or after shipping an actor update

What it does — Runs Input Guard, Deploy Guard, and Output Guard in sequence, then aggregates results into one weighted report with cross-stage analysis. Best for — CI/CD gates, pre-deploy validation, post-deploy monitoring, actor fleet quality management Speed — 3-10 minutes depending on target actor complexity and stage count Pricing — $0.25 per pipeline run (plus sub-actor PPE: Input $0.15, Deploy $2.50, Output $4.00) Output — JSON report with overall score, per-stage results, cross-stage analysis, and recommendations

Key limitation: Guard Pipeline requires all three sub-actors to be accessible under the same Apify account token. What it is not: Not a deployment tool, not a code fixer, and not a replacement for manual code review. Does not include: Automatic remediation, code modification, or production deployment. Results may be incomplete when: the target actor has no default input configured, or when individual guard stages time out.

What you get from one call

Input: "ryanclinton/website-contact-scraper" Returns:

• Overall status (pass/warn/fail/block) and weighted score (0-100)
• Per-stage breakdown: input score, deploy score, output score with summaries
• Cross-stage analysis: escaped regression detection, schema change tracking, deploy-vs-production agreement
• Aggregated recommendations from all three stages
• Cross-stage feedback loop suggestions (e.g., "tighten input validation based on output failures")
• Rollup with total critical/warning counts and recommended action

Typical time to first result: 3-8 minutes. Typical time to integrate: Under 15 minutes with the API examples below.

What makes this different

• Cross-stage intelligence — Guard Pipeline detects escaped regressions where deploy passes but output fails, a signal no individual guard produces
• Weighted scoring — The overall score weights output quality highest (45%), deploy health second (35%), and input correctness lowest (20%), reflecting real-world impact
• One run, one verdict — Instead of managing three separate actor runs and correlating results manually, Guard Pipeline returns a single actionable report

If you are building this yourself, you would need to orchestrate three Actor.call invocations, normalize their output schemas, compute weighted scores, detect cross-stage regressions, and maintain a shared KV store for history tracking.

Quick answers

What is Guard Pipeline? Guard Pipeline is an orchestrator that runs Input Guard, Deploy Guard, and Output Guard in sequence against any target actor and returns a unified quality report.

What makes it different from running each guard separately? Guard Pipeline adds cross-stage analysis — escaped regression detection, input schema change tracking, deploy-vs-production agreement scoring, and cross-stage feedback suggestions. These signals only emerge when stages are compared.

What data sources does it use? Guard Pipeline calls three sub-actors by their Apify actor IDs. Each sub-actor validates a different lifecycle stage using the target actor's schema, builds, and output data.

What does it return? A JSON report with an overall weighted score (0-100), per-stage status and scores, cross-stage analysis, aggregated recommendations, and a rollup with recommended action.

How much does it cost? $0.25 per pipeline run. Sub-actor PPE is billed separately: Input Guard $0.15, Deploy Guard $2.50, Output Guard $4.00. A full three-stage run costs approximately $6.90 total.

Can I run only some stages? Yes. The stages parameter accepts any combination of ["input", "deploy", "output"]. Guard Pipeline redistributes score weights proportionally among the stages you run.

At a glance

Quick facts:

• Input: Target actor ID (required), optional test input, optional stage selection
• Output: JSON report with weighted score, per-stage results, cross-stage analysis, recommendations
• Pricing: $0.25 per pipeline run (sub-actor PPE billed separately)
• Stages: Input Guard ($0.15) + Deploy Guard ($0.75) + Output Guard ($0.50)
• Score weights: Input 20%, Deploy 35%, Output 45%
• Status precedence: block > fail > warn > pass
• History: Stores last 100 pipeline runs per actor in a shared KV store
• Memory: 256 MB default, 128-512 MB range

Input → Output:

• Input: Actor ID + optional test input and stage configuration
• Process: Runs up to 3 guard stages sequentially, aggregates results, performs cross-stage analysis
• Output: Unified pipeline report with weighted score, findings, and recommendations

Best fit: CI/CD quality gates, pre-deploy validation, actor fleet health monitoring, regression detection after updates Not ideal for: Real-time monitoring (runs take 3-10 minutes), actors without default inputs, one-off quick checks where a single guard suffices Does not include: Code fixes, auto-deployment, or production traffic routing

Problems this solves:

• How to validate an actor across input, deploy, and output in one step
• How to detect regressions that pass deploy checks but fail in production output
• How to track actor quality trends over time with historical scoring
• How to get a single go/no-go verdict before deploying an actor update

Common questions Guard Pipeline answers:

Is this actor safe to deploy? Guard Pipeline returns a clear status (pass/warn/fail/block) with a recommended action, so you know whether to ship, review, or stop.

Did my last update break output quality? The escaped regression detector flags cases where deploy passed but output degraded.

Which stage is causing the most issues? Per-stage scores and the key findings list pinpoint whether problems originate in input validation, deploy health, or output quality.

Has the input schema changed since baseline? Cross-stage analysis compares the current schema hash against stored baselines and flags changes.

When to use Guard Pipeline vs individual Guards

Use Guard Pipeline when:

• You want a single quality verdict across all three lifecycle stages
• You need cross-stage analysis (escaped regressions, schema drift, deploy-vs-production agreement)
• You are integrating actor validation into a CI/CD pipeline and want one API call
• You manage multiple actors and want consistent, comparable quality reports

Use individual Guards when:

• You only need to check one specific stage (e.g., output monitoring only)
• You want faster results — a single guard runs in 1-3 minutes vs 3-10 for the pipeline
• You want to save cost — running only Output Guard costs $4.00 vs $6.90 for the full pipeline

Stage	Guard	Price	What it prevents
Before run	Input Guard	$0.15	Bad input wasting runs
Before deploy	Deploy Guard	$0.75	Broken builds reaching production
After deploy	Output Guard	$0.50	Silent data failures
Full lifecycle	Guard Pipeline	$0.25	All of the above in one run

How to validate an actor with Guard Pipeline

1. Enter the target actor ID — Provide the actor ID or full name (e.g., ryanclinton/website-contact-scraper) in the targetActorId field
2. Configure stages — Leave the default ["input", "deploy", "output"] to run all three, or pick specific stages
3. Run Guard Pipeline — Click "Start". A full three-stage run takes 3-10 minutes depending on target actor complexity
4. Review the report — Open the Dataset tab to see the unified report with overall score, per-stage breakdowns, and recommendations

First run tips

• Start with all three stages — Running all stages gives you cross-stage analysis that individual guards cannot produce
• Use the default test input first — Guard Pipeline passes the target actor's default/prefill input if you leave testInput empty. Only customize it if the defaults are insufficient
• Check the recommended action — The rollup.recommendedAction field gives a plain-language verdict: "Safe to deploy", "Review warnings", "Investigate failures", or "Block deployment"
• Enable skipOnBlock — This is on by default. If Input Guard blocks, it skips Deploy and Output Guards to save time and cost
• Set a webhook for CI/CD — Use alertWebhookUrl to POST the full report to Slack or your build system

Features

Guard Pipeline orchestrates three quality gates and produces cross-stage intelligence that individual guards cannot generate. The weighted scoring system prioritizes output quality (45%) over deploy health (35%) and input correctness (20%), reflecting the real-world impact of each stage.

Orchestration:

• Sequential stage execution — Runs Input Guard, Deploy Guard, and Output Guard in fixed order with configurable timeout per stage
• Configurable stage selection — Run all three stages or pick any subset; score weights redistribute proportionally
• Skip on block — When enabled, a block status from any stage skips all remaining stages to save time and cost
• Per-stage resource control — Configure timeout (60-3600s) and memory (128-4096 MB) per sub-actor run

Cross-stage analysis:

• Escaped regression detection — Flags when Deploy Guard passes but Output Guard fails, indicating a regression that slipped through deploy checks
• Input schema change tracking — Compares current schema hash against stored baselines to detect schema drift
• Deploy-vs-production agreement — Reports whether deploy and output stages agree (full/partial/none) on drift and status
• Cross-stage feedback suggestions — Generates actionable suggestions like "tighten input validation" or "add drift coverage to deploy tests"

Reporting:

• Weighted overall score — 0-100 score computed from stage weights (input 20%, deploy 35%, output 45%)
• Status precedence — Overall status follows strict precedence: block > fail > warn > pass
• Aggregated recommendations — Collects and deduplicates recommendations from all stages, prefixed with stage name
• Key findings rollup — Summarizes critical issues, warning counts, and drift status across all stages
• Webhook alerts — POST the full pipeline report to any URL (Slack, CI/CD, custom endpoints)

History and state:

• Shared AQP KV store — Stores BASELINES, HISTORY, LATEST, and SUGGESTIONS per actor in a named KV store
• Run history — Maintains last 100 pipeline runs per actor for trend analysis
• Artifact linking — Report includes run IDs for each sub-actor, linking back to individual guard results

Use cases for actor quality validation

Best for CI/CD quality gates

Use when you deploy actors through automated pipelines. Guard Pipeline provides a single pass/fail/block verdict that a build system can evaluate. Key outputs: overall status, recommended action, per-stage scores.

Best for pre-release validation

Use when an actor update is ready to ship but you want confidence it will not break production. Guard Pipeline catches escaped regressions — cases where deploy checks pass but output quality degrades. Key outputs: cross-stage analysis, escaped regression flag, recommendations.

Best for actor fleet monitoring

Use when managing 10+ actors and you need a consistent quality metric across the portfolio. Schedule Guard Pipeline runs for each actor on a weekly cadence. Key outputs: overall score trend (via HISTORY KV store), key findings, drift detection.

Best for post-incident triage

Use after a production failure to understand which lifecycle stage broke down. Guard Pipeline shows whether the issue originated in input validation, deploy health, or output quality. Key outputs: per-stage status, key findings by stage, cross-stage agreement.

Input parameters

Parameter	Type	Required	Default	Description
targetActorId	string	Yes	—	Actor ID or full name (e.g., ryanclinton/website-contact-scraper) to validate
testInput	object	No	{}	Input object to pass to the target actor during guard checks
stages	array	No	["input", "deploy", "output"]	Which guard stages to run. Order is always input, deploy, output
deployPreset	string	No	—	Preset name for Deploy Guard (e.g., quick, thorough)
deployTestCases	array	No	—	Custom test cases array passed to Deploy Guard
fieldImportanceProfile	object	No	—	Field importance weights passed to all three guard stages
outputMode	string	No	monitor	Output Guard mode: validate (one-shot) or monitor (drift tracking)
enableDriftTracking	boolean	No	true	Whether Output Guard tracks output drift across runs
fieldRules	object	No	—	Field-level validation rules passed to Output Guard
alertWebhookUrl	string	No	—	Webhook URL to POST the full report to (e.g., Slack incoming webhook)
timeout	integer	No	300	Per-stage timeout in seconds (60-3600). A 120s buffer is added for overhead
memory	integer	No	512	Per-stage memory allocation in MB (128-4096)
skipOnBlock	boolean	No	true	Skip remaining stages if any stage returns block status

Input examples

Full lifecycle validation (default):

{
    "targetActorId": "ryanclinton/website-contact-scraper"
}

Selective stages with custom test input:

{
    "targetActorId": "ryanclinton/website-contact-scraper",
    "stages": ["deploy", "output"],
    "testInput": {
        "urls": ["https://acmecorp.com"]
    },
    "outputMode": "validate"
}

Full configuration with webhook and custom deploy preset:

{
    "targetActorId": "ryanclinton/website-contact-scraper",
    "stages": ["input", "deploy", "output"],
    "testInput": {
        "urls": ["https://acmecorp.com", "https://northstarlogistics.com"]
    },
    "deployPreset": "thorough",
    "fieldImportanceProfile": {
        "email": 1.0,
        "phone": 0.8,
        "name": 0.6
    },
    "outputMode": "monitor",
    "enableDriftTracking": true,
    "alertWebhookUrl": "https://hooks.slack.com/services/T00/B00/xxx",
    "timeout": 600,
    "memory": 1024,
    "skipOnBlock": true
}

Input tips

• Leave testInput empty for first runs — Guard Pipeline passes the target actor's default/prefill input, which covers most validation scenarios
• Use validate mode for one-off checks — The monitor mode tracks drift over time, but validate is faster for pre-deploy spot checks
• Increase timeout for complex actors — Actors with long builds or slow test runs may need 600s+ per stage
• Set field importance profiles — If certain output fields matter more than others, the profile propagates to all three stages

Output example

{
    "wrapperVersion": 1,
    "actorId": "ryanclinton/website-contact-scraper",
    "actorName": "Website Contact Scraper",
    "runId": "abc123def456",
    "startedAt": "2026-04-07T14:00:00.000Z",
    "finishedAt": "2026-04-07T14:06:42.000Z",
    "overallStatus": "warn",
    "overallScore": 74,
    "summary": "Pipeline WARN (score 74/100). 3 stage(s) completed.",
    "stageResults": {
        "input": {
            "status": "pass",
            "score": 92,
            "summary": "Input schema is valid with minor suggestions."
        },
        "deploy": {
            "status": "pass",
            "score": 85,
            "summary": "Build succeeded. All test cases passed."
        },
        "output": {
            "status": "warn",
            "score": 58,
            "summary": "Output drift detected in 3 fields. Email extraction rate below baseline."
        }
    },
    "rollup": {
        "criticalIssues": 0,
        "warningIssues": 4,
        "driftDetected": true,
        "recommendedAction": "Review warnings before deploying. Consider addressing recommendations."
    },
    "keyFindings": [
        {
            "stage": "output",
            "severity": "warning",
            "field": null,
            "message": "4 warning(s) detected"
        },
        {
            "stage": "output",
            "severity": "warning",
            "field": null,
            "message": "Output drift detected"
        }
    ],
    "crossStageAnalysis": {
        "inputSchemaChanged": false,
        "deployVsProductionAgreement": "partial",
        "suspectedEscapedRegression": false,
        "escapedRegressionReason": null
    },
    "recommendations": [
        "[input] Consider adding description to 3 input fields",
        "[deploy] Add edge-case test for empty URL list",
        "[output] Email extraction rate dropped 12% from baseline — investigate source changes",
        "[output] Add field rules for phone number format validation"
    ],
    "suggestions": [
        {
            "sourceStage": "output",
            "targetStage": "deploy",
            "type": "add-drift-coverage",
            "field": null
        }
    ],
    "stateRefs": {
        "profileKey": "PROFILE",
        "baselinesKey": "BASELINES",
        "historyKey": "HISTORY",
        "suggestionsKey": "SUGGESTIONS"
    },
    "artifacts": {
        "inputRunId": "run_inp_001",
        "deployRunId": "run_dep_002",
        "outputRunId": "run_out_003"
    }
}

Output fields

Field	Type	Description
wrapperVersion	number	Pipeline report schema version
actorId	string	Target actor ID as provided in input
actorName	string	Resolved display name of the target actor
runId	string	Guard Pipeline run ID
startedAt	string	ISO timestamp when the pipeline started
finishedAt	string	ISO timestamp when the pipeline finished
overallStatus	string	Aggregated status: pass, warn, fail, or block
overallScore	number	Weighted score 0-100 (input 20%, deploy 35%, output 45%)
summary	string	One-sentence pipeline result
stageResults	object	Per-stage status, score, and summary for each completed stage
stageResults.{stage}.status	string	Stage status: pass, warn, fail, or block
stageResults.{stage}.score	number	Stage score 0-100
stageResults.{stage}.summary	string	Stage result summary
rollup.criticalIssues	number	Total critical issues across all stages
rollup.warningIssues	number	Total warnings across all stages
rollup.driftDetected	boolean	Whether any stage detected output drift
rollup.recommendedAction	string	Plain-language recommended action
keyFindings	array	List of key findings with stage, severity, and message
crossStageAnalysis.inputSchemaChanged	boolean	Whether the input schema hash changed since baseline
crossStageAnalysis.deployVsProductionAgreement	string	Agreement level: full, partial, or none
crossStageAnalysis.suspectedEscapedRegression	boolean	Whether deploy passed but output failed
crossStageAnalysis.escapedRegressionReason	string	Explanation when an escaped regression is detected
recommendations	array	Aggregated recommendations prefixed with stage name
suggestions	array	Cross-stage feedback loop suggestions with source/target stage and type
stateRefs	object	KV store key names for PROFILE, BASELINES, HISTORY, SUGGESTIONS
artifacts.inputRunId	string	Run ID of the Input Guard sub-actor run
artifacts.deployRunId	string	Run ID of the Deploy Guard sub-actor run
artifacts.outputRunId	string	Run ID of the Output Guard sub-actor run

How much does it cost to run Guard Pipeline?

Guard Pipeline uses pay-per-event pricing — you pay $0.25 per pipeline run. Sub-actor PPE is billed separately by each guard stage. Platform compute costs are included.

Scenario	Stages	Pipeline cost	Sub-actor cost	Total cost
Quick check (input only)	1	$0.25	$0.15	$0.40
Deploy + output	2	$0.25	$6.50	$6.75
Full lifecycle	3	$0.25	$6.65	$6.90
Weekly fleet check (10 actors)	3 each	$15.00	$14.00	$29.00
Daily CI/CD (1 actor, 30 days)	3 each	$45.00	$42.00	$87.00

Guard Pipeline always charges $0.25 regardless of how many stages run. The sub-actor costs scale with which stages are selected. You can set a spending limit on your Apify account to control costs. Apify's free tier includes $5 of monthly credits.

Validate actors using the API

Python

from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")

run = client.actor("ryanclinton/guard-pipeline").call(run_input={
    "targetActorId": "ryanclinton/website-contact-scraper",
    "stages": ["input", "deploy", "output"],
    "outputMode": "monitor",
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(f"Status: {item['overallStatus']} | Score: {item['overallScore']}/100")
    print(f"Summary: {item['summary']}")
    if item.get("crossStageAnalysis", {}).get("suspectedEscapedRegression"):
        print(f"WARNING: Escaped regression detected")
    for rec in item.get("recommendations", []):
        print(f"  - {rec}")

JavaScript

import { ApifyClient } from "apify-client";

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

const run = await client.actor("ryanclinton/guard-pipeline").call({
    targetActorId: "ryanclinton/website-contact-scraper",
    stages: ["input", "deploy", "output"],
    outputMode: "monitor",
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
for (const item of items) {
    console.log(`Status: ${item.overallStatus} | Score: ${item.overallScore}/100`);
    console.log(`Summary: ${item.summary}`);
    if (item.crossStageAnalysis?.suspectedEscapedRegression) {
        console.log("WARNING: Escaped regression detected");
    }
    for (const rec of item.recommendations || []) {
        console.log(`  - ${rec}`);
    }
}

cURL

curl -X POST "https://api.apify.com/v2/acts/ryanclinton~guard-pipeline/runs?token=YOUR_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "targetActorId": "ryanclinton/website-contact-scraper",
    "stages": ["input", "deploy", "output"],
    "outputMode": "monitor"
  }'

curl "https://api.apify.com/v2/datasets/DATASET_ID/items?token=YOUR_API_TOKEN&format=json"

How Guard Pipeline works

Mental model: Target actor ID → Input Guard → Deploy Guard → Output Guard → cross-stage analysis → unified report.

Stage execution

Guard Pipeline calls each sub-actor using Actor.call() with configurable timeout and memory. Stages run in fixed order: input, deploy, output. If skipOnBlock is enabled (default), a block status from any stage cancels all remaining stages. Each sub-actor produces a standardized result with status, score, summary, recommendations, and signal counts.

Score aggregation

Guard Pipeline computes a weighted overall score from completed stages. The weights are input 20%, deploy 35%, output 45%. When only a subset of stages runs (either by configuration or skip-on-block), Guard Pipeline redistributes the weights proportionally among the completed stages. The overall status follows strict precedence: if Input or Deploy Guard returns block, the pipeline blocks. If Output Guard fails, the pipeline fails. Otherwise, any warn produces a warning, and all-pass produces a pass.

Cross-stage analysis

After all stages complete, Guard Pipeline compares results across stages. Escaped regression detection checks whether Deploy Guard passed or warned but Output Guard failed — indicating a regression that slipped through deploy tests. Schema change detection compares the current input schema hash against the stored baseline. Deploy-vs-production agreement checks whether deploy and output stages agree on drift status and overall health.

State management

Guard Pipeline maintains a named KV store (AQP__{actorId}) per target actor. It writes LATEST (last pipeline result), HISTORY (last 100 runs for trend analysis), and SUGGESTIONS (cross-stage feedback). It reads BASELINES for schema hash comparison. The SUMMARY key is written to the default run KV store for quick access.

Tips for best results

1. Run all three stages on the first pass — Cross-stage analysis produces the most value when all stages contribute data. Skip stages only after establishing baselines.
2. Schedule weekly runs per actor — Use Apify scheduling to run Guard Pipeline on a recurring basis. The HISTORY KV store tracks quality trends over time.
3. Use field importance profiles for data-heavy actors — If your actor produces 20+ fields but only 5 matter for your pipeline, set weights so those fields drive the score.
4. Set outputMode to monitor for production actors — Monitor mode tracks drift across runs, building baselines that improve detection accuracy over time.
5. Connect a webhook for CI/CD integration — Use alertWebhookUrl to send the full report to Slack or your build system. Parse overallStatus for automated go/no-go decisions.
6. Increase timeout for actors with slow builds — Deploy Guard runs a build, which can take 2-5 minutes for large actors. Set timeout to 600 or higher.

Combine with other actors

Actor	How to combine
Input Guard	Run standalone for quick input schema checks ($0.15) when you do not need full lifecycle validation
Deploy Guard	Run standalone for pre-deploy build testing ($0.75) when you only need build health verification
Output Guard	Run standalone for output monitoring ($0.50) when you only need drift tracking and data quality checks
Website Contact Scraper	Use Guard Pipeline to validate Website Contact Scraper before deploying updates that affect email extraction
B2B Lead Gen Suite	Validate pipeline actors before deployment to prevent cascading failures in multi-step lead workflows
Website Tech Stack Detector	Run Guard Pipeline after tech stack detection updates to verify output schema stability

Limitations

• Pipeline cost is fixed — Guard Pipeline charges $0.25 per run regardless of how many stages complete or are skipped. Running a single stage still costs $0.25 plus that stage's PPE
• Sequential execution only — Stages run one after another, not in parallel. A full three-stage run takes 3-10 minutes
• Sub-actor availability — Guard Pipeline requires all three sub-actors (Input Guard, Deploy Guard, Output Guard) to be accessible. If any sub-actor is unavailable or broken, that stage errors
• No automatic remediation — Guard Pipeline reports issues but does not fix them. Developers must act on the recommendations manually
• Timeout cascading — The per-stage timeout applies to each stage individually. A slow target actor may cause timeouts in Deploy or Output Guard stages
• KV store naming — The shared AQP KV store uses a naming convention based on the actor ID. Renaming or moving an actor breaks the history chain
• No real-time monitoring — Guard Pipeline is a batch operation. For continuous monitoring, schedule recurring runs rather than expecting live alerts

Integrations

• Apify API — Trigger Guard Pipeline from CI/CD systems using the REST API
• Webhooks — POST the full pipeline report to Slack, PagerDuty, or custom endpoints via alertWebhookUrl
• Zapier — Trigger downstream workflows when Guard Pipeline reports a block or fail status
• Make — Build automated quality gates that run Guard Pipeline before deploying actor updates
• Google Sheets — Export pipeline scores to a spreadsheet for fleet-wide quality dashboards

Troubleshooting

Guard Pipeline times out on Deploy Guard stage. Deploy Guard runs a build of the target actor, which can take several minutes for large codebases. Increase the timeout parameter to 600 or higher. The pipeline adds a 120-second buffer on top of the configured timeout.

One stage errors but others succeed. Guard Pipeline continues to the next stage even if a previous stage errors (unless skipOnBlock triggers). The errored stage appears in the report with an error message and null result. The overall score only factors in completed stages.

The overall score seems too low despite most stages passing. Output Guard has the highest weight (45%). A low output score pulls the overall score down significantly. Check the output stage's detailed findings for specific issues.

Webhook does not fire. Verify the alertWebhookUrl is a valid URL that accepts POST requests with JSON body. Guard Pipeline logs webhook failures as warnings but does not retry.

History KV store is empty. Guard Pipeline creates the KV store on the first run. If you changed the target actor ID or the actor was renamed, the store name changes and history resets.

Responsible use

• Guard Pipeline validates publicly accessible actor metadata, builds, and outputs. It does not bypass authentication or access restricted content.
• Users are responsible for ensuring their use complies with applicable laws and platform terms, including data protection regulations in their jurisdiction.
• Do not use Guard Pipeline to validate actors you do not own or have permission to test.
• For guidance on web scraping legality, see Apify's guide.

FAQ

Can I use Guard Pipeline in a CI/CD pipeline? Yes. Use the API to trigger Guard Pipeline after each commit or before each deploy. Parse the overallStatus field — pass or warn means safe to proceed, fail or block means stop. The webhook integration sends the full report to your build system.

How is Guard Pipeline different from running each guard individually? Guard Pipeline adds cross-stage analysis that individual guards cannot produce. Escaped regression detection identifies when deploy passes but output fails. Schema change tracking compares input across runs. Cross-stage feedback suggestions connect output failures back to input or deploy improvements.

Can I run Guard Pipeline on actors I did not build? Yes, as long as the target actor is accessible with your API token. Guard Pipeline calls each guard with the target actor ID and your token. Public actors are accessible to all accounts.

What happens if a stage returns block? When skipOnBlock is enabled (default), Guard Pipeline skips all remaining stages. The report shows skipped stages with a reason. The overall status is block. This saves time and cost when a critical issue is found early.

How does the weighted scoring work? Guard Pipeline assigns weights to each stage: input 20%, deploy 35%, output 45%. If you skip a stage, the weights redistribute proportionally. For example, running only deploy and output weights them 43.75% and 56.25% respectively.

Can I track quality trends over time? Yes. Guard Pipeline stores the last 100 runs per actor in a named KV store under the HISTORY key. Each entry includes the timestamp, overall status, overall score, and per-stage results. Use the Apify API to read the KV store and build trend charts.

Is Guard Pipeline worth the cost vs running guards separately? Guard Pipeline costs $0.25 plus sub-actor PPE ($6.65 for all three stages), totaling $6.90 per full run. Running the three guards separately costs $6.65 total but requires manual orchestration and produces no cross-stage analysis. The $0.25 premium buys escaped regression detection, schema change tracking, and automated aggregation.

What does "escaped regression" mean? An escaped regression occurs when Deploy Guard passes (or warns) but Output Guard fails. This means the actor built and deployed without errors, but its production output quality degraded. Guard Pipeline flags this pattern because it indicates test coverage gaps in the deploy stage.

Can I customize which fields matter most in the quality score? Yes. Use the fieldImportanceProfile parameter to assign weights to specific output fields. This profile propagates to all three guard stages, so input validation, deploy testing, and output monitoring all prioritize the same fields.

How long does a full Guard Pipeline run take? A typical three-stage run takes 3-8 minutes. The bulk of the time is spent in Deploy Guard (which runs a build) and Output Guard (which runs the target actor). Input Guard is fastest, typically completing in under 1 minute.

Is it legal to validate actors with Guard Pipeline? Guard Pipeline accesses publicly available actor metadata, schemas, and build artifacts through the Apify API. Legality depends on your jurisdiction and the target actor's terms. Guard Pipeline does not access private data or bypass any restrictions. Consult legal counsel if unsure.

Can I use Guard Pipeline with actors that have no default input? Guard Pipeline passes the testInput you provide. If testInput is empty and the actor has no default/prefill input, some guard stages may produce incomplete results. Always provide a representative testInput for actors without configured defaults.

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.