/ WordPress Webhook Plugin — Event Delivery Infrastructure

Reliable webhook delivery
from any WordPress action

Treat WordPress as a first-class event source for automation. Deliver structured, durable, and observable webhook events to n8n, Make, Zapier, or any API — with retries, unique event identity, and full delivery logging built in.

Install Free Plugin Pro See How It Works
Smart Retry & Reply
Every webhook event has a delivery log with retries and replay support.

Production-grade webhook delivery for WordPress · WordPress 6.0+ · PHP 8.0+ · Free & Open Source (GPL)
⭐ If this helps you automate reliably, please leave a review on WordPress.org.

/ The problem

WordPress automation often fails silently in production

The real problem isn’t just “sending a webhook.” It’s missing **event durability**, **retry guarantees**, and a **feedback loop into WordPress** when deliveries fail.

/ The solution

A production-ready event delivery layer for WordPress

Instead of fragile point-to-point integrations, treat WordPress as a resilient event source that can power automation workflows with confidence.

/ Features

Infrastructure-grade features for reliable automation

Async Queue

Events are stored and processed independently of the request cycle — enabling durable delivery, backpressure handling, and faster front-end response times regardless of endpoint latency.

  • Decouple slow third-party APIs from WordPress page loads
  • Process high-volume event bursts without dropping deliveries
  • Survive server restarts with persistent queue storage
Async Queue — event queue with pending jobs and processing status Async Queue

Smart Retry Logic

Exponential backoff with jitter classifies failures as retryable or permanent — so transient network errors are retried while bad endpoints are quarantined automatically.

  • Automatic retries with exponential backoff
  • Permanent failure classification stops infinite retries
  • Manual replay from the dashboard for any past event
Smart Retry — retry attempts with exponential backoff and failure classification Smart Retry

Webhook Chains

Compose multi-step automations declaratively. A webhook's 2xx response fires one or more downstream webhooks, each receiving the upstream response, sent payload, and pre-mapping original payload — so a single WordPress event can drive a full external graph without ad-hoc wp_remote_post() glue.

  • Save-time cycle detection prevents infinite loops across chains
  • Per-link conditions route each hop independently — branch on response fields, build dual-path flows
  • Every chained hop is a real webhook with its own log, retry, conditions, and replay
Webhook Chains — chain group view in admin showing a parent webhook with downstream chained targets Webhook Chains

Delivery Logs

Every attempt is recorded with HTTP status codes, response bodies, and timing — so debugging an integration failure takes seconds, not guesswork.

  • Full response body stored per attempt
  • Filter by status, endpoint, or event type
  • Automated audit trail for compliance and QA
Delivery Logs — attempt history with HTTP status codes and response bodies Delivery Logs

Payload Mapping

Transform structured JSON before dispatch so it matches the schema expected by your automation platform, CRM, or API — without custom glue code in between.

  • Map WordPress hook data to any target field structure
  • Flatten nested objects or rename keys before sending
  • Live JSON preview while building mappings
Payload Mapping — field mapping editor with live JSON preview Payload Mapping

Event Identity

Each event gets a UUID and precise timestamp at capture time — enabling idempotent processing, deduplication, and reliable auditing in external systems.

  • UUID per event for idempotent consumers
  • Timestamps preserved across retries
  • Traceable from WordPress hook to endpoint response
Event Identity — UUID and timestamp assigned to each captured webhook event Event Identity

Conditional Dispatch

Filter events before they fire — send webhooks only when payload field values match your conditions. Eliminate noise and stop wasting downstream API quota on irrelevant events.

  • Field-level conditions on any payload value
  • Combine multiple conditions with AND/OR logic
  • No wasted API calls on filtered-out events
Conditional Dispatch — field-level conditions to filter which events are sent Conditional Dispatch

Configurable HTTP Method, Headers & Query Params

Send webhooks as GET, POST, PUT, PATCH, or DELETE — with per-webhook custom request headers and URL query parameters. Header and param values can reference payload fields via dot-notation so auth tokens, IDs, or any dynamic value travels correctly without extra glue code.

  • Choose HTTP method per webhook — GET, POST, PUT, PATCH, or DELETE
  • Add custom request headers with static or payload-resolved values
  • Append query parameters to the URL for any HTTP method
HTTP Method, Custom Headers & Query Params — per-webhook configuration of request method, headers, and URL parameters HTTP Method & Headers

Synchronous First Attempt

Optionally fire a webhook inline during the WordPress request — skipping the queue for the initial attempt. Useful for integrations that need an immediate response, while still falling back to the async retry queue if the endpoint is unavailable.

  • Immediate delivery during the triggering WordPress request
  • Automatic handoff to async retry queue on failure
  • Per-webhook toggle — keep other webhooks fully async
Synchronous Execution — per-webhook toggle to fire inline during the WordPress request Synchronous Execution

REST API

Full operational REST API for creating webhooks, delivery logs, retry triggers, queue status, and webhook management — usable by CI/CD pipelines, external dashboards, and AI agents.

  • Trigger retries or replays programmatically
  • Query delivery stats from external monitoring tools
  • Manage webhooks from headless or CLI environments
REST API — API endpoints for webhook management and delivery log access REST API

Developer Extensibility

Filters and actions let you adjust dispatch logic, headers, timeouts, retry behavior, and error handling — so the plugin fits production requirements without forking core code.

  • Override request headers or auth per endpoint
  • Hook into pre/post-dispatch to add custom logic
  • Adjust timeouts and retry policy at the hook level
Developer Extensibility — filters and actions for customizing dispatch behavior Extensibility

Test Delivery

Send a test webhook instantly or via the async queue without triggering real WordPress events. Debug integrations safely against live endpoints before activating in production.

  • Fire test payloads to any configured endpoint
  • Choose immediate or queued delivery for testing
  • Inspect the full response without production impact
Test Delivery — send test webhooks without triggering real WordPress events Test Delivery

Everything you need — nothing you don't.

Queue, retry, logs, conditions, payload mapping, and full HTTP control. Free and open source.

Download on WordPress.org Pro View on GitHub
/ Preview

See it in action

Create Webhook
Setting up a Gravity Forms webhook trigger
Payload Mapping
Field mapping with live JSON preview
Smart Retry & Reply
Automatic retries with full delivery log
Form to Webhook
Gravity Forms submission delivered via webhook
/ How it works

Three steps to resilient event delivery

01

WordPress fires an event

Any native or custom do_action — from user registration to WooCommerce order completion.

02

Event is captured and queued

Structured JSON payloads are built and stored for durable processing — outside the request lifecycle.

03

Reliable delivery to your endpoint

The event is dispatched asynchronously, retried automatically on failures, and logged for observability.

Example: WordPress fires user_register
// WordPress core fires this action when a new user registers do_action( 'user_register', $user_id ); // The plugin automatically captures it and sends a webhook: { "hook": "user_register", "args": [ 42 ], "timestamp": 1736934600, "site_url": "https://example.com", "user": { "ID": 42, "user_email": "[email protected]", "display_name": "Jane Smith", "roles": [ "subscriber" ] } }

No listener code. No custom integration. Configure the hook in the admin panel — the plugin handles the rest.

/ Use cases

Real-world automation workflows

WooCommerce → ERP

Sync orders to your ERP

Send WooCommerce order data to your ERP system on every new order, status change, or refund.

WordPress → CRM

Sync users to your CRM

Automatically push new user registrations and profile updates to HubSpot, Salesforce, or any CRM via webhook. See the HubSpot × WooCommerce series for a full 5-part walkthrough: deals, products, line items, contacts, and the dual-path chain that ties them into one HubSpot graph.

Post Publish → Automation

Trigger workflows on publish

Notify Slack, update a spreadsheet, or trigger an n8n workflow every time a post or custom post type is published.

Custom Hook → n8n

Connect custom plugin events

Fire webhooks from any custom do_action in your theme or plugin — membership events, form submissions, anything. See the Contact Form 7 to webhook example for a full walkthrough.

WordPress → Microservices

Feed internal systems

Push WordPress events to internal APIs, message queues, or microservices for processing outside the WordPress stack.

REST API → AI Agent

AI-driven automation

AI agents and CI/CD pipelines inspect delivery logs, retry failed events, and manage webhook configuration programmatically via scoped API tokens — no admin session required.

Browse all integration examples →

/ Integrations

Works with any webhook-compatible system

n8n

Workflow Automation

Zapier

App Integration

Make

Visual Automation

Custom APIs

Any HTTP Endpoint

Any system that accepts HTTP POST requests with JSON payloads works out of the box. Configure the URL, add an optional authorization header, and you're connected.

Connect WordPress to any platform in minutes.

If it accepts an HTTP request, you can send it a webhook. No glue code, no vendor lock-in.

Download on WordPress.org Pro View on GitHub
/ Technical details

Built for reliability and performance

Non-Blocking HTTP

Webhook requests are dispatched outside the main request lifecycle. User-facing pages are never slowed down by outbound HTTP calls. For a deeper technical explanation of non-blocking architecture, see Async Webhooks Without Blocking in WordPress, and for why most webhook implementations silently fail in production, see Why WordPress Webhooks Silently Fail in Production.

Custom Queue Engine

Jobs are queued in a custom database table and processed in batches. Designed for system cron or a token‑protected REST endpoint for reliable, high‑frequency processing — with WP‑Cron as a fallback. For a deeper look at why WP‑Cron isn’t reliable for background jobs and how async webhook queues improve reliability and scalability in WordPress, see our technical article: Async Webhooks in WordPress — Why WP‑Cron Is Not Enough. To set up a proper cron job for WordPress — including system crontab, WP-CLI, and Action Scheduler — see Cron Job for WordPress: WP-Cron Limits and Real Fixes.

Exponential Backoff

Failed deliveries retry with increasing delays: 1 min, 2 min, 4 min, 8 min — up to 1 hour. Default 5 attempts, configurable via filter. For a full walkthrough of retry and replay architecture, see Inside My Webhook Retry & Replay System.

JSON Schema

Payloads follow a consistent structure: hook name, arguments, timestamp, site URL. Field mapping lets you reshape data for any external schema.

WordPress-Native

Built on WordPress APIs — wp_remote_post for HTTP, dedicated custom tables for fast storage and queries. Developer-friendly with filters and actions to customize every aspect. No external dependencies.

Filter-Based Extensibility

13 filters and 4 actions let you customize every aspect: dispatch conditions, payload transformation, headers, timeouts, and error handling.

/ Conditions & Testing

Send only what matters — and test before it counts

Conditional Dispatch

Each webhook can have conditions evaluated against the incoming payload before dispatch. Set a field path, pick an operator, and set a value — the event is skipped silently if the condition fails.

Supported operators: equals, not equals, contains, starts with, ends with, greater than, less than, empty, not empty. Works against strings, numbers, booleans, and null values.

Free plan: one condition, AND match. Webhook Actions Pro adds unlimited conditions, condition groups, and AND/OR logic per group.

Built-in Field Selector

Store an example payload from a real event, then use the field selector to browse the payload tree and pick the exact field to match against — no manual dot-notation guessing.

The condition preview updates live as you configure it, so you can verify the match logic against your real data before saving.

Test Delivery — Run Now

Fire a test webhook from the admin panel instantly, bypassing the async queue. The response is shown immediately — HTTP status, body, and duration — without creating a real WordPress event or queue job.

Use it to verify endpoint connectivity, authentication headers, and payload shape before going live.

Test Delivery — Queue Mode

Send the same test event through the full async queue pipeline — including retry logic, backoff, and delivery logging — to validate the complete end-to-end flow under the same conditions as production.

The test event appears in delivery logs like any real event, so you can inspect the attempt history and response body after processing.

/ Developer API

Full control via filters, actions, and REST API

Filters
fswa_should_dispatch fswa_payload fswa_normalize_object fswa_headers fswa_require_https fswa_max_attempts fswa_backoff_delay fswa_queue_batch_size fswa_http_timeout fswa_http_connect_timeout fswa_http_args fswa_available_triggers fswa_webhook_data
Actions
fswa_success fswa_error fswa_skipped fswa_webhook_saved
Example: conditionally skip dispatch
add_filter( 'fswa_should_dispatch', function( $should, $hook, $args ) { // Skip dispatch for admin users if ( $hook === 'wp_login' && user_can( $args[1], 'manage_options' ) ) { return false; } return $should; }, 10, 3 );
Example: normalize a CF7 form object for the webhook payload

Some plugins pass objects with private properties — or require additional PHP calls — to produce the data you actually want in the payload. fswa_normalize_object lets you intercept any such object before serialization and return a plain array instead. A common case is Contact Form 7, which fires wpcf7_mail_sent with a WPCF7_ContactForm instance whose submission data is only accessible via a separate API call.

add_filter( 'fswa_normalize_object', function( $data, $object ) { if ( !$object instanceof WPCF7_ContactForm ) { return $data; } $submission = WPCF7_Submission::get_instance(); return [ 'id' => $object->id(), 'title' => $object->title(), 'fields' => $submission ? $submission->get_posted_data() : [], ]; }, 10, 2 );

The filter fires per object in the hook arguments. Return the original $data for any object you don't need to handle — the plugin's default serializer takes over. See the CF7 to webhook example for the full integration walkthrough.

REST API

The plugin exposes a full operational REST API (/wp-json/fswa/v1/) that powers the admin interface and can also be used directly by external tools, automation systems, AI agents, and CI/CD pipelines. Endpoints cover delivery logs, event inspection, retry and replay triggers, queue status, webhook configuration, and API token management. Secured with scoped tokens (read, operational, full) passed as X-FSWA-Token, Authorization: Bearer, or a query parameter. See the full REST API reference, the REST API guide for monitoring, recovery, and CI/CD usage patterns, or Create and Manage WordPress Webhooks Programmatically for the control layer — creating, updating, listing, and deleting webhooks via API without touching wp-admin.

AI Agents & CI/CD

Because the API exposes operational endpoints for logs, queue jobs, webhooks, and triggers, external agents can treat WordPress as programmable event infrastructure — without requiring an admin session.

Monitor delivery health Retry failed events automatically Inspect logs to debug integrations Enable / disable webhooks during deployments Query queue metrics for alerting

Example: a Claude Code agent analyzes delivery logs and retries failed integrations. A CI/CD pipeline disables webhook triggers before a deployment and re-enables them after. An external dashboard polls queue health metrics via API token.

Requirements: WordPress 6.0+ · PHP 8.0+ · Tested up to WordPress 6.9
/ Frequently Asked Questions

Common questions answered

WP webhooks (WordPress webhooks) are HTTP POST requests sent automatically by WordPress when specific events occur — like a new order, a user registration, or a post being published.

This plugin adds production-grade WP webhook delivery to WordPress with async queuing, automatic retries, payload mapping, and full delivery logging — so every event reaches your automation platform reliably.
A WordPress action is a hook that runs at a specific moment during WordPress execution. For example: when a user registers, a post is updated, an order is completed, or a product is created.

This plugin allows you to trigger HTTP webhooks whenever those actions occur.
Yes. The plugin is fully compatible with n8n Webhook Trigger nodes.

Simply create a webhook in n8n, copy the URL, and paste it into the plugin. Structured JSON payloads are sent automatically when the selected WordPress or WooCommerce action fires.
Yes. You can connect it to Zapier, Make, Pipedream, or any system that supports incoming HTTP webhooks.

No vendor lock-in. No proprietary API.
Yes. Any WooCommerce action can be used as a trigger, including:
  • woocommerce_order_status_completed
  • woocommerce_new_order
  • woocommerce_product_set_stock
  • and many more
As long as the hook exists, it can trigger a webhook.
If a webhook request fails (for example, due to a temporary network issue or a 500 error), the plugin automatically retries using exponential backoff.

Example retry schedule:
1 minute → 2 minutes → 4 minutes → 8 minutes → up to 1 hour.

By default, 5 attempts are made before marking the webhook as permanently failed. Developers can modify this behavior using filters.
Yes. Every webhook delivery is logged with its payload and attempt history.
You can replay any event directly from the logs, which is useful for debugging integrations or re-running automation workflows.
Payload Mapping allows you to transform the outgoing JSON payload. You can:
  • rename fields
  • restructure nested data
  • remove sensitive values
  • normalize payloads for external APIs
The plugin can store sample payloads to make mapping easier.
Yes. For user-related actions (user_register, profile_update, wp_login, wp_logout), you can enable "Include User Data".

This automatically attaches structured user information such as:
  • user ID
  • email
  • display name
  • roles
  • registration date
Yes. Webhook requests are sent via HTTP POST using structured JSON. You can secure endpoints using authentication methods supported by your automation platform (for example, secret keys or signature validation).
Yes. The plugin is fully open-source and licensed under GPL. You are free to use, modify, and extend it.
★ ★ ★ ★ ★
"Solid plugin. Super easy to set up and it just works. If you need reliable webhooks this makes the whole process a lot easier."
Axel — WordPress.org review
Webhook Actions Plugin walkthrough

Treat WordPress as a dependable event source

Install Webhook Actions by Flow Systems and make event delivery in WordPress deterministic, retry-safe, and observable.

Download on WordPress.org Pro View on GitHub