Home / CI/CD / Fix Jenkins Pipeline Approval Timeout

CI/CD

Fix Jenkins Pipeline Approval Timeout

Resolve Jenkins pipeline approval timeout by adjusting input step timeout and handling approval expiry gracefully.

Published: Apr 5, 20268 min readBy FixWikiHub Editorial Team

Abstract illustration for a troubleshooting knowledge base category.

Introduction

Jenkins pipeline input steps timeout when waiting for manual approval. The pipeline fails or proceeds with default action after timeout expires.

Symptoms

Input timeout in logs:

groovy

[Pipeline] input
Waiting for approval...
Input requested: Deploy to production?
Timeout expired after 30 minutes
Proceeding with default action: 'Abort'

Pipeline aborted:

groovy

org.jenkinsci.plugins.workflow.steps.input.InputStepExecution$TimeoutExpiredException: Input timed out

Build failed:

```bash $ curl -s http://jenkins:8080/job/my-job/123/consoleText

ERROR: Input step timed out after 30m Build aborted ```

Common Causes

1.Timeout too short - Approval takes longer than configured
2.Approver unavailable - No one available to approve
3.Wrong timeout unit - Minutes vs seconds confusion
4.No default action - Timeout without fallback
5.Build executor blocked - Executor held during input wait
6.Approval permissions - Approver lacks permissions

Step-by-Step Fix

1.Check logs for specific error messages
2.Verify configuration settings
3.Test network connectivity
4.Review recent changes
5.Apply corrective action
6.Verify the fix

Step 1: Check Input Configuration

```groovy // In pipeline script: input message: 'Deploy to production?', submitter: 'admin,release-team', submitterParameter: 'approver', parameters: [ string(name: 'environment', defaultValue: 'prod') ]

// Check timeout configuration: input message: 'Approve deployment?', timeout: 30, // Default: unit depends on context timeoutUnit: 'MINUTES'

// View in Jenkins: # Job > Build > Console Output # Shows input configuration ```

Step 2: Adjust Timeout Settings

```groovy // Increase timeout: input message: 'Deploy to production?', timeout: 60, timeoutUnit: 'MINUTES'

// Or use SECONDS: input message: 'Quick approval needed', timeout: 300, timeoutUnit: 'SECONDS'

// Or use HOURS for long processes: input message: 'Security review required', timeout: 4, timeoutUnit: 'HOURS'

// No timeout (wait indefinitely): input message: 'Waiting for approval' // No timeout parameter

// In Jenkinsfile: pipeline { agent any stages { stage('Approval') { input { message "Deploy to production?" ok "Deploy" timeout(time: 60, unit: 'MINUTES') submitter "admin,release-team" } steps { sh 'deploy.sh' } } } } ```

Step 3: Configure Default Action

```groovy // Set default action on timeout: input message: 'Deploy to production?', timeout: 30, timeoutUnit: 'MINUTES', ok: 'Proceed', // Button to proceed submitter: 'admin'

// Handle timeout in script: try { timeout(time: 30, unit: 'MINUTES') { input message: 'Approve deployment?', submitter: 'admin' } // Approved - proceed with deployment sh 'deploy.sh' } catch (org.jenkinsci.plugins.workflow.steps.input.InputAbortedException e) { echo 'Input aborted or timed out' // Handle abort sh 'cleanup.sh' }

// Or use proceed parameter: input message: 'Deploy?', timeout: 30, timeoutUnit: 'MINUTES', submitter: 'admin', ok: 'Deploy', abort: 'Skip' // Button to abort ```

Step 4: Check Approver Permissions

```bash # Check who can approve curl -s http://jenkins:8080/job/my-job/config | grep submitter

# In Jenkins UI: # Manage Jenkins > Manage Roles (if Role Strategy plugin) # Or: Job > Configure > Build Triggers

# Check user permissions: curl -s http://jenkins:8080/user/admin/api/json | jq '.id'

# Approver must have: # - Job build permission # - Input submit permission

# In pipeline, specify approvers: input message: 'Deploy?', submitter: 'admin,release-team', // User IDs or groups submitterParameter: 'approver' // Capture who approved

# Check approver list: curl -s "http://jenkins:8080/job/my-job/123/input" | jq '.proceedText' ```

Step 5: Handle Executor Blocking

```groovy // Input step blocks executor by default // Use 'wait: false' to not block:

input message: 'Approve deployment?', submitter: 'admin', wait: false // Don't block executor

// This creates a separate task for approval // Pipeline continues without blocking executor

// Or use milestone to prevent parallel: milestone label: 'Before approval' input message: 'Approve?' milestone label: 'After approval'

// Check executor usage: curl -s http://jenkins:8080/computer/api/json | jq '.busyExecutors' ```

Step 6: Check Build Logs

```bash # View build console: curl -s http://jenkins:8080/job/my-job/123/consoleText

# Check for timeout messages: curl -s http://jenkins:8080/job/my-job/123/consoleText | grep -i timeout

# Look for: # - "Timeout expired" # - "Input requested" # - "Waiting for approval"

# Check Jenkins logs: cat /var/log/jenkins/jenkins.log | grep -i input

# Or journalctl: journalctl -u jenkins | grep -i "input|timeout"

# Check waiting builds: curl -s http://jenkins:8080/job/my-job/api/json?tree=builds[number,result,actions[waitingInput]] | jq '.builds[] | select(.actions[].waitingInput)' ```

Step 7: Approve Via API

```bash # If timeout approaching, approve via API:

# Check if input waiting: curl -s http://jenkins:8080/job/my-job/123/input

# Get input ID: curl -s http://jenkins:8080/job/my-job/123/input/id

# Approve: curl -X POST http://jenkins:8080/job/my-job/123/input/proceed \ -u "admin:api-token" \ -H "Content-Type: application/json" \ -d '{"environment": "prod"}'

# Or abort: curl -X POST http://jenkins:8080/job/my-job/123/input/abort \ -u "admin:api-token"

# Check approval status: curl -s http://jenkins:8080/job/my-job/123/api/json | jq '.result' ```

Step 8: Configure Email Notifications

```groovy // Send email when waiting for approval: emailext subject: "Approval needed for ${env.JOB_NAME} #${env.BUILD_NUMBER}", body: "Pipeline waiting for your approval.\n\n${env.BUILD_URL}input", to: 'release-team@example.com'

input message: 'Deploy to production?', submitter: 'admin,release-team'

// Send timeout notification: try { timeout(time: 30, unit: 'MINUTES') { emailext subject: "Approval needed", body: "Waiting for approval. Will timeout in 30 minutes.", to: 'release-team@example.com' input message: 'Approve?', submitter: 'admin' } } catch (Exception e) { emailext subject: "Approval timeout", body: "Pipeline timed out waiting for approval", to: 'release-team@example.com' } ```

Step 9: Use Conditional Logic

```groovy // Handle approval result: def approval = input message: 'Deploy?', submitter: 'admin', parameters: [ choice(name: 'action', choices: ['deploy', 'skip', 'rollback'], description: 'Choose action') ]

switch(approval.action) { case 'deploy': sh 'deploy.sh' break case 'skip': echo 'Skipping deployment' break case 'rollback': sh 'rollback.sh' break }

// Or capture approver: def result = input message: 'Approve?', submitter: 'admin,release-team', submitterParameter: 'approver'

echo "Approved by: ${result.approver}" ```

Step 10: Monitor Input Steps

```groovy // Create approval tracking: pipeline { agent any stages { stage('Approval') { steps { script { def startTime = System.currentTimeMillis() try { timeout(time: 30, unit: 'MINUTES') { input message: 'Approve?', submitter: 'admin' } def duration = (System.currentTimeMillis() - startTime) / 1000 / 60 echo "Approval took ${duration} minutes" } catch (Exception e) { def duration = (System.currentTimeMillis() - startTime) / 1000 / 60 echo "Timed out after ${duration} minutes" currentBuild.result = 'ABORTED' } } } } } }

// Track in metrics: // Use Prometheus plugin to track approval durations ```

Jenkins Pipeline Approval Checklist

Check	Location	Expected
Timeout value	input step	Sufficient for approval
Timeout unit	input step	Correct (MINUTES/HOURS)
Approver list	submitter	Valid users/groups
Permissions	Role Strategy	Build + Input permission
Default action	input step	Handle timeout gracefully
Executor block	wait parameter	Avoid blocking

Verification

```bash # After adjusting timeout

# 1. Run pipeline with approval # Job > Build with Parameters

# 2. Check input waiting curl -s http://jenkins:8080/job/my-job/123/input // Input waiting for approval

# 3. Wait extended time (60 minutes) # No timeout error

# 4. Approve via UI or API curl -X POST http://jenkins:8080/job/my-job/123/input/proceed // Proceeded successfully

# 5. Check build result curl -s http://jenkins:8080/job/my-job/123/api/json | jq '.result' // SUCCESS

# 6. Review approval log curl -s http://jenkins:8080/job/my-job/123/consoleText | grep -i approved // Approved by: admin ```

[Fix Jenkins Build Queue Stuck](/articles/fix-jenkins-build-queue-stuck)
[Fix Jenkins Pipeline SCM Checkout Failed](/articles/fix-jenkins-pipeline-scm-checkout-failed)
[Fix Jenkins Agent Offline](/articles/fix-jenkins-agent-offline)

[Technical troubleshooting: Fix Cicd Artifact Upload Failed Storage Issue in C](cicd-artifact-upload-failed-storage)
[Technical troubleshooting: Fix Cicd Code Quality Gate Failed Sonarqube Issue ](cicd-code-quality-gate-failed-sonarqube)
[Technical troubleshooting: Fix Cicd Deployment Failed Health Check Issue in C](cicd-deployment-failed-health-check)
[Technical troubleshooting: Fix Cicd Github Actions Workflow Queue Timeout in ](cicd-github-actions-workflow-queue-timeout)
[Technical troubleshooting: Fix Cicd Gitlab Runner Stuck Pending Issue in CI/C](cicd-gitlab-runner-stuck-pending)

Was this guide helpful?

Related search paths

People also search for

If the symptom is close but not identical, these search paths usually surface the right neighboring fixes faster than scrolling the full archive.

Jenkins Pipeline Approval Timeout Jenkins Pipeline Approval Timeout CI/CD Jenkins Pipeline Approval Timeout troubleshooting Jenkins Pipeline Approval Timeout fix Resolve Jenkins pipeline approval timeout by adjusting input step timeout and handling approval expiry gracefully CI/CD Resolve Jenkins pipeline approval timeout by adjusting input step timeout and handling approval expiry gracefully

Explore Related Topics

Browse Guides from Other Categories

Discover troubleshooting guides from related categories to expand your knowledge.

FAQ

CI/CD Troubleshooting FAQs

Common questions about troubleshooting and preventing similar issues

How do I know if this cicd-errors troubleshooting guide applies to my situation?

This guide is designed for cicd-errors issues. If you're experiencing similar symptoms described in the article, follow the step-by-step instructions. Start with the most common causes and work through the diagnostic process.

Is it safe to follow these cicd-errors troubleshooting steps?

Yes, all steps are designed to be safe and non-destructive. We recommend creating backups before making significant changes and testing each step before proceeding to the next.

How long does it typically take to resolve this type of cicd-errors issue?

Most cicd-errors issues can be resolved within 30 minutes to 2 hours, depending on the complexity and root cause. Follow the troubleshooting flow to identify and fix the problem efficiently.

How can I prevent this cicd-errors issue from happening again?

Regular maintenance, monitoring, and following best practices for cicd-errors configuration can help prevent recurrence. Consider implementing automated checks and alerts for early detection.

Written by

FixWikiHub Editorial Team

Our editorial team consists of experienced DevOps engineers, systems administrators, and cloud architects with hands-on experience in production environments across AWS, Azure, GCP, and on-premises infrastructure.

Every guide undergoes technical review for accuracy and is updated when software versions, commands, or best practices change.

Last updated: Apr 5, 2026

About our team

Important Notice

Disclaimer & Safety Guidelines

The troubleshooting steps in this guide are provided for educational and informational purposes. Before applying any changes to production systems:

Test in a staging environment first — Always verify commands and configurations in a non-production environment before deploying to live systems.
Create backups — Ensure you have current backups of databases, configurations, and critical files before making changes.
Understand the impact — Review how each step may affect your specific environment, dependencies, and users.
Consult official documentation — This guide supplements, but does not replace, official vendor documentation and best practices.

FixWikiHub is not responsible for any damages arising from the use of this content. See our Terms of Use for more information.

Resources

Official Documentation & Further Reading

For authoritative information, consult the official documentation for the technologies discussed in this guide. Our troubleshooting content supplements, but does not replace, vendor documentation.

AWS Documentation — Official Amazon Web Services guides and API references
Kubernetes Documentation — Official Kubernetes documentation
Nginx Documentation — Official Nginx web server documentation
Apache Documentation — Official Apache HTTP Server documentation
Docker Documentation — Official Docker container documentation

Fix Jenkins Pipeline Approval Timeout

Introduction

Symptoms

Common Causes

Step-by-Step Fix

Step 1: Check Input Configuration

Step 2: Adjust Timeout Settings

Step 3: Configure Default Action

Step 4: Check Approver Permissions

Step 5: Handle Executor Blocking

Step 6: Check Build Logs

Step 7: Approve Via API

Step 8: Configure Email Notifications

Step 9: Use Conditional Logic

Step 10: Monitor Input Steps

Jenkins Pipeline Approval Checklist

Verification

People also search for

Browse Guides from Other Categories

WordPress

SSL

DNS

CI/CD Troubleshooting FAQs

FixWikiHub Editorial Team

Disclaimer & Safety Guidelines

Official Documentation & Further Reading

Fix Jenkins Pipeline Approval Timeout

Introduction

Symptoms

Common Causes

Step-by-Step Fix

Step 1: Check Input Configuration

Step 2: Adjust Timeout Settings

Step 3: Configure Default Action

Step 4: Check Approver Permissions

Step 5: Handle Executor Blocking

Step 6: Check Build Logs

Step 7: Approve Via API

Step 8: Configure Email Notifications

Step 9: Use Conditional Logic

Step 10: Monitor Input Steps

Jenkins Pipeline Approval Checklist

Verification

Related Issues

Related Articles

People also search for

Share this guide

More CI/CD Troubleshooting Guides

Browse Guides from Other Categories

CI/CD Troubleshooting FAQs

FixWikiHub Editorial Team

Disclaimer & Safety Guidelines

Official Documentation & Further Reading