This article provides a complete, practical walkthrough of the Splitout Code Update Webhook n8n agent. It connects HTTP Request, Webhook across approximately 1 node(s). Expect a Intermediate setup in 15-45 minutes. One‑time purchase: €29.

What This Agent Does

This agent orchestrates a reliable automation between HTTP Request, Webhook, handling triggers, data enrichment, and delivery with guardrails for errors and rate limits.

It streamlines multi‑step processes that would otherwise require manual exports, spreadsheet cleanup, and repeated API requests. By centralizing logic in n8n, it reduces context switching, lowers error rates, and ensures consistent results across teams.

Typical outcomes include faster lead handoffs, automated notifications, accurate data synchronization, and better visibility via execution logs and optional Slack/Email alerts.

How It Works

The workflow uses standard n8n building blocks like Webhook or Schedule triggers, HTTP Request for API calls, and control nodes (IF, Merge, Set) to validate inputs, branch on conditions, and format outputs. Retries and timeouts improve resilience, while credentials keep secrets safe.

Third‑Party Integrations

• HTTP Request
• Webhook

Import and Use in n8n

1. Open n8n and create a new workflow or collection.
2. Choose Import from File or Paste JSON.
3. Paste the JSON below, then click Import.
4. Show n8n JSON

   Title:  
   Automated Docker Registry Cleanup Using n8n: A Complete Workflow Breakdown
   
   Meta Description:  
   Learn how to automate Docker image cleanup with an n8n workflow that removes outdated tags, retains the most recent builds, and notifies users—keeping your Docker registry storage optimized effortlessly.
   
   Keywords:  
   Docker, n8n, DevOps automation, Docker registry cleanup, container management, CI/CD, garbage collection, image tag management, API automation, workflow orchestration
   
   Third-Party APIs and Services Used:
   
   - Docker Registry HTTP API v2 (private Docker registry endpoints)
   - SMTP (for sending email notifications)
   - SSH (for remote garbage collection command execution)
   
   Article:
   
   Managing Docker images efficiently is essential for maintaining disk space and ensuring your container registry remains streamlined and performant. Over time, as DevOps pipelines build and push hundreds of container tags, the registry can become cluttered with outdated versions that take up unnecessary resources.
   
   To address this challenge, we’ve designed an automated Docker registry cleanup workflow using n8n, a popular open-source workflow automation tool. This workflow automatically deletes old tags while preserving the most recent tags to maintain operational continuity. It even sends out email notifications for successful and failed removal attempts and cleans the backend registry data using Docker’s garbage collection feature.
   
   In this article, we’ll walk you through the details of this n8n automation, its key components, and how it leverages the Docker Registry API for efficient tag lifecycle management.
   
   📅 Scheduled Cleanup Trigger
   
   At the heart of the automation is the Scheduled Trigger node. It kicks off the cleanup daily at 1 AM, ensuring your registry remains lean without any manual intervention.
   
   🔍 Discovering Docker Images and Tags
   
   The cleanup begins with a call to the /v2/_catalog endpoint using the List Images node to retrieve all available image repositories. The Extract Image Names node then uses custom JavaScript to transform the raw JSON into separate execution items for each image.
   
   Next, each image is processed through the Retrieve Image Tags node, which queries the Docker Registry’s /tags/list endpoint to fetch available tags.
   
   📦 Tag Metadata Extraction
   
   Once the tags are listed, the workflow filters out empty names or tags using the Filter Valid Tags node to avoid invalid data.
   
   To retrieve detailed metadata, such as the image digest and creation timestamp, the workflow performs an HTTP request via the Fetch Manifest Digest node. This engages the Docker Registry API to get the tag manifest, including its digest header.
   
   Further metadata is fetched in Fetch Manifest Digest for Blob, followed by a field tidy-up in Update Fields, which structures each image’s metadata—name, tag, creation date, and digest—for sorting and deletion decisions.
   
   🧠 Smart Cleanup Logic
   
   The Group Tags by Image and Identify Tags to Remove nodes perform intelligent decision-making based on tag metadata.
   
   This JavaScript logic keeps the latest 10 non-"latest" tags and always preserves the “latest” tag if present. All others are marked for deletion, ensuring a clean registry that retains essential image versions.
   
   🗑️ Removing Old Tags and Running Garbage Collection
   
   Each unneeded tag is deleted via the Remove Old Tags node using an HTTP DELETE request to the respective Docker Registry manifest URL. If a deletion fails, the workflow captures the error and passes the information to the Send Failure Notification Email node, alerting the team.
   
   If deletion succeeds, a confirmation is sent via the Send Notification Email node.
   
   Once these steps are complete, the Execute Garbage Collection node runs a remote SSH command to invoke Docker Registry’s garbage-collect binary. This permanently removes untagged blobs from disk space, ensuring efficient storage usage.
   
   📬 Proactive Notifications
   
   The workflow sends two types of notifications:
   
   - On successful tag removal: A simple email indicating the image and tag removed.
   - On failure: A detailed alert to aid debugging and ensure no unnoticed cleanup failures.
   
   This dual-notification setup ensures DevOps teams stay informed about the registry’s health without manually checking logs or UIs.
   
   🔒 Authentication and Security
   
   Each HTTP Request node is authenticated with basic HTTP auth credentials, assuming access to a private Docker Registry. Likewise, the SSH node uses a private key for secure command execution.
   
   📈 Final Thoughts
   
   This n8n workflow is a robust, automated solution for Docker registry maintenance. By intelligently retaining only the latest tags, sending actionable notifications, and automating cleanup tasks, it helps organizations reduce storage costs and streamline CI/CD workflows.
   
   Whether you’re managing a growing microservices architecture or aiming to enforce best practices in image management, this workflow makes it simple, scalable, and efficient.
   
   Get started today with n8n and keep your Docker environment clean—automatically.
   
   💡 Pro Tip: You can integrate this workflow into a broader DevOps pipeline, connecting it to Slack, Jira, or GitHub for even tighter operational feedback and control.

5. Set credentials for each API node (keys, OAuth) in Credentials.
6. Run a test via Execute Workflow. Inspect Run Data, then adjust parameters.
7. Enable the workflow to run on schedule, webhook, or triggers as configured.

Tips: keep secrets in credentials, add retries and timeouts on HTTP nodes, implement error notifications, and paginate large API fetches.

Validation: use IF/Code nodes to sanitize inputs and guard against empty payloads.

Why Automate This with AI Agents

AI‑assisted automations offload repetitive, error‑prone tasks to a predictable workflow. Instead of manual copy‑paste and ad‑hoc scripts, your team gets a governed pipeline with versioned state, auditability, and observable runs.

n8n’s node graph makes data flow transparent while AI‑powered enrichment (classification, extraction, summarization) boosts throughput and consistency. Teams reclaim time, reduce operational costs, and standardize best practices without sacrificing flexibility.

Compared to one‑off integrations, an AI agent is easier to extend: swap APIs, add filters, or bolt on notifications without rewriting everything. You get reliability, control, and a faster path from idea to production.

Best Practices

• Credentials: restrict scopes and rotate tokens regularly.
• Resilience: configure retries, timeouts, and backoff for API nodes.
• Data Quality: validate inputs; normalize fields early to reduce downstream branching.
• Performance: batch records and paginate for large datasets.
• Observability: add failure alerts (Email/Slack) and persistent logs for auditing.
• Security: avoid sensitive data in logs; use environment variables and n8n credentials.

FAQs

Can I swap integrations later? Yes. Replace or add nodes and re‑map fields without rebuilding the whole flow.

How do I monitor failures? Use Execution logs and add notifications on the Error Trigger path.

Does it scale? Use queues, batching, and sub‑workflows to split responsibilities and control load.

Is my data safe? Keep secrets in Credentials, restrict token scopes, and review access logs.