# Posthook > Webhook scheduler with delivery tracking, retries, and failure alerting built in. One API call to schedule, full visibility into every delivery. Posthook is a webhook scheduler. Schedule reminders, follow-ups, notifications, and expirations with one API call. Every delivery is tracked with retries, anomaly alerting, and operational visibility built in. No cron to maintain. No workflow engine to learn. ## What Posthook Does You make one API call with a target URL, a timestamp, and an optional JSON payload. Posthook holds the hook and delivers it as an HTTP POST at the scheduled time. If delivery fails, Posthook retries automatically based on your retry configuration. Each event creates its own timer, persisted, retried on failure, cancellable, and observable. Posthook is not a queue, workflow engine, or messaging platform. It coexists with all of these. Queues handle "process now," workflows handle "orchestrate these steps," Posthook handles "make this happen at this time." Common use cases: - Reminders and follow-ups: onboarding nudges, trial warnings, abandoned cart recovery - Expiration and timeout checks: invitation expiry, reservation holds, trial enforcement - Durable debounce: consolidate noisy event streams into a single action after activity settles - Status polling and check-later: self-rescheduling check chains for async tasks - Integration and webhook bridges: delayed handoffs between systems with retries and visibility - Calendar-based recurring tasks via sequences ## API Quickstart ### Schedule a Hook ```bash curl -X POST https://api.posthook.io/v1/hooks \ -H "X-API-Key: YOUR_API_KEY" \ -H "Content-Type: application/json" \ -d '{ "path": "/webhooks/reminder", "postAt": "2026-06-15T10:00:00Z", "data": { "userId": "user_123", "action": "send_reminder" } }' ``` The response includes the hook ID and delivery status. ### Get a Hook ```bash curl https://api.posthook.io/v1/hooks/{hookId} \ -H "X-API-Key: YOUR_API_KEY" ``` ### List Hooks ```bash curl "https://api.posthook.io/v1/hooks?limit=25&status=pending&sortBy=postAt&sortOrder=asc" \ -H "X-API-Key: YOUR_API_KEY" ``` ## Key Features ### One-Time Scheduling POST a hook with a target URL and ISO 8601 timestamp. Posthook delivers it at the scheduled time as an HTTP POST request with your JSON payload in the body. ### Recurring Sequences & Config-as-Code Define recurring workflows that fire on a calendar schedule — hourly, daily, weekly, or monthly — in any IANA timezone. DST transitions are handled automatically. Sequences support multi-step workflows with dependency resolution between steps. Sequences are managed as code via a `posthook.toml` configuration file. You check it into git, diff changes, and deploy with the CLI: ```toml # posthook.toml — Sync CRM data every Mon/Wed/Fri at 9 AM ET [[sequences]] name = "crm-sync" [sequences.schedule] frequency = "weekly" timezone = "America/New_York" time = { hour = 9, minute = 0 } on_days = ["monday", "wednesday", "friday"] [sequences.steps.sync] path = "/webhooks/crm/sync" [sequences.steps.notify] path = "/webhooks/crm/notify" depends_on = ["sync"] ``` Validate and deploy: `npx posthook apply`. Preview changes: `npx posthook diff`. ### Configurable Retries Choose between fixed-interval or exponential backoff retry strategies. Add jitter to prevent thundering herd. Set up to 15 retry attempts depending on your plan. ### Real-Time Dashboard Monitor all deliveries in a web dashboard. Inspect request/response payloads, filter by status, and take bulk actions on hooks. ### Anomaly Detection and Failure Alerts Per-endpoint failure rate tracking against a rolling baseline. A single failure on a normally-healthy endpoint (one whose normal success rate is 100%) is enough to trigger an alert via email, Slack, or webhook. Recovery notifications follow when the endpoint returns to normal. Alert speed ranges from 15 minutes (Free) to 30 seconds (Scale). No threshold to set — sensitivity is keyed to each endpoint's own baseline. ### Bulk Incident Response A database outage causes 500 hooks to fail. One API call retries all failed hooks in a time range, filtered by endpoint or sequence. No one-at-a-time replay. ### Async Hooks Endpoints return 202 Accepted and call back via ack or nack URLs with a body. Configurable timeouts up to 3 hours. Nack bodies are captured for inspection. ### Receiving and Verifying Hooks Every delivery includes a signature header. Use the SDK's `parseDelivery(body, headers)` to verify the signature and parse a typed delivery in one call. Configure your framework to keep the request body raw (e.g., `express.raw({ type: '*/*' })` for Node, equivalent middleware for Fastify or other frameworks) so the signature can be computed against the bytes Posthook signed. The delivery object exposes `.data` (typed payload), `.hookId`, `.postAt`, and `.postedAt`. See https://docs.posthook.io/essentials/receiving-webhooks for the full pattern with error handling. ### CLI Listener Run `npx posthook listen` to receive hooks locally during development via WebSocket. Accept, fail, or timeout each delivery interactively. ### Official SDKs - **Go**: `go get github.com/posthook/posthook-go` - **Python**: `pip install posthook-python` - **TypeScript/Node.js**: `npm install @posthook/node` ## Authentication All API requests require an API key passed via the `X-API-Key` header. Get your API key from the Posthook dashboard at https://posthook.io/app/dashboard. Keys use the `phk_` prefix. ``` X-API-Key: phk_your_api_key ``` ## Pricing | Plan | Price | Hooks/Month | Projects | Concurrent Deliveries | |------|-------|-------------|----------|-----------------------| | Free | $0 | 1,000 | 3 | 10 | | Launch | $39/mo | 20,000 | 5 | 50 | | Growth | $99/mo | 100,000 | 15 | 100 | | Scale | $249/mo | 500,000 | 50 | 400 | Only hook scheduling counts toward quota. Retries, deliveries, and API calls are included. No overages. At 100% quota you can use up to 150% before new hooks are rejected. Count resets on the 1st of each month. ## Reliability - Hooks are committed to a persistent message queue before the API responds - Multi-AZ infrastructure on Google Cloud - PostgreSQL with synchronous replication and automatic failover - At-least-once delivery with configurable retries - 99.98% uptime since 2018 - 8 years of continuous production operation ## Scheduling Patterns Posthook is designed for durable time-based patterns where each event creates its own timer. The handler checks state at delivery time and decides whether to act or skip — this is the primary safety mechanism. ### Reminders and Follow-Ups Four design principles for reliable reminders: (1) the scheduled job carries only an identifier, (2) the handler looks up state and decides act-or-skip, (3) timezone belongs at scheduling time (DST is the scheduler's problem), (4) each step in a multi-step chain is its own scheduled job. Each event creates its own timer; the happy path includes no-ops. https://posthook.io/patterns/reminders-followups ### Expiration and Timeout Checks Four design principles for reliable per-object expirations: (1) schedule the expiration when the object is created (not by polling), (2) the deadline triggers a check, not an action — the handler decides whether to expire or skip, (3) rescheduling is a new hook, not a coordination problem (the handler's state check covers extensions), (4) time-sensitivity drives precision and retry policy (use per-hook retry overrides for payment holds and magic links). https://posthook.io/patterns/expiration-timeouts ### Durable Debounce Schedule one check on the first event in a burst. Handler decides: act (activity settled), reschedule (still active), or skip (already handled). Survives restarts and coordinates across instances. https://posthook.io/patterns/durable-debounce ### Status Polling and Check-Later Self-rescheduling check chains for async tasks. Schedule a check when the task starts; handler checks status and either completes, escalates, or schedules the next check. https://posthook.io/patterns/status-polling-check-later ### Integration and Webhook Bridges Delayed handoffs between systems. Receive an inbound webhook, schedule a follow-up to a downstream service. Consistent retry behavior and visibility across all bridges. https://posthook.io/patterns/integration-webhook-bridges ## Solutions ### Serverless Scheduling Serverless platforms handle "something happens now, respond to it" well. They do not handle "remember to do something later" well. Platform cron features cover static recurring schedules, but production applications need dynamic, per-event scheduling — reminders, expirations, follow-ups. Posthook fills this gap across Vercel, Netlify, Cloudflare Workers, and AWS Lambda without adding persistent infrastructure. https://posthook.io/solutions/serverless-scheduling ### Schedule API Calls Schedule an HTTP POST or WebSocket delivery to your endpoint at any future time. One API call to schedule, managed delivery with retries and observability. Your handler receives the delivery and runs whatever logic the moment requires. SDKs for Node.js, Python, and Go — or use the HTTP/JSON API directly from any language. https://posthook.io/solutions/schedule-api-calls ### Reminder API Per-user reminder and notification scheduling with timezone-aware delivery. Posthook is a timing layer — it handles when to fire, and your application handles what to send. Works with any email, SMS, or push provider you already use. Distinct from customer engagement platforms (Customer.io, Braze) that own the full notification lifecycle. Includes scenario-specific code for trial expiration sequences, appointment reminders with rescheduling, onboarding nudge chains, and support case follow-up with escalation. https://posthook.io/solutions/reminder-api ### Expiration API Per-object expiration scheduling for trials, invitations, offers, and payment holds. Schedule a hook at the deadline when the object is created; the handler reads current state and decides whether to expire or skip. Time-sensitive expirations (payment holds, magic links, reservation slots) use per-hook retry overrides for shorter delays and more attempts than batch-grade expirations. Distinct from cron+scan approaches: each object gets its own scheduled hook, with no polling subsystem and no precision floor at the cron interval. Includes scenario-specific code for trial expiration with downgrade, invitation expiry with extension, offer/promo code expiration, and pending order/payment hold timeout. https://posthook.io/solutions/expiration-api ### Alongside Your Stack You already have queues, maybe a workflow engine, and definitely cron. Posthook handles the part they were not designed for: making things happen at the right time, with visibility into whether they did. Your endpoint receives the hook delivery and enqueues a job in BullMQ, SQS, Celery, or Sidekiq. Posthook handles the scheduling. Your queue handles the execution. https://posthook.io/solutions/alongside-your-stack ## Comparisons ### Cron vs Durable Scheduling Cron works for recurring system tasks. A webhook scheduler like Posthook is better when the work is per-event: reminders, expirations, retries. Each event gets its own timer with retries, cancellation, and observability. https://posthook.io/compare/cron-vs-durable-scheduling ### BullMQ vs Posthook BullMQ is a Redis-backed job queue for Node — queue-first with in-process workers. Posthook is time-first with managed delivery. Use BullMQ for job processing, Posthook for durable time-based delivery. They complement each other. https://posthook.io/compare/bullmq-vs-posthook ### QStash vs Posthook QStash is a serverless HTTP message queue — strong at fan-out, batch publishing, FIFO queues. Posthook is scheduling-first with per-endpoint anomaly detection, bulk incident response, timezone-aware scheduling, and config-as-code. https://posthook.io/compare/qstash-vs-posthook ### Temporal vs Posthook Temporal is a durable execution platform for stateful workflows. Posthook is a managed scheduling service for time-based delivery. Temporal is the right tool for complex orchestration; Posthook solves scheduling with less adoption cost and operational burden. https://posthook.io/compare/temporal-vs-posthook ### Inngest / Trigger.dev vs Posthook Inngest and Trigger.dev are durable function platforms that own your execution. Posthook is a scheduling service that stays out of your code. Choose a function platform for multi-step workflows with branching; choose Posthook for time-based delivery without adopting a new runtime. https://posthook.io/compare/inngest-trigger-vs-posthook ### Vercel Cron vs Posthook Vercel Cron Jobs handle fixed recurring tasks defined in vercel.json — no retry, UTC only, no dynamic scheduling. Posthook handles dynamic scheduling from API routes and server actions, with retries, timezone-aware delivery, and anomaly detection. Posthook Sequences replace Vercel Cron for recurring work with more power and reliability. https://posthook.io/compare/vercel-cron-vs-posthook ### Sidekiq vs Posthook Sidekiq is the standard for background job processing in Ruby — Redis-backed, in-process workers, deep Rails integration. Posthook handles durable time-based delivery without Redis or workers. Use Sidekiq for queue work, Posthook for timing work. https://posthook.io/compare/sidekiq-vs-posthook ### Celery vs Posthook Celery is a distributed task queue for Python with Redis or RabbitMQ. Posthook is a managed scheduling service. Celery is the right tool for in-process Python task execution. Posthook handles scheduled delivery without queue infrastructure. https://posthook.io/compare/celery-vs-posthook ### EventBridge Scheduler vs Posthook AWS EventBridge Scheduler supports one-time and recurring schedules with retries and up to 10M schedules per region. Posthook offers per-delivery observability, anomaly detection, and bulk incident response without IAM complexity or AWS lock-in. https://posthook.io/compare/eventbridge-vs-posthook ### Cloud Scheduler vs Posthook Google Cloud Scheduler is a managed cron service for GCP with HTTP targets. Posthook adds dynamic one-time scheduling, per-delivery observability, anomaly detection, and platform independence. https://posthook.io/compare/cloud-scheduler-vs-posthook ### Cloud Tasks vs Posthook Google Cloud Tasks supports delayed HTTP execution with a 30-day maximum delay. Posthook supports scheduling up to 365 days (postIn) or any future date (postAt), with per-delivery tracking and anomaly detection. https://posthook.io/compare/cloud-tasks-vs-posthook ### Heroku Scheduler vs Posthook Heroku Scheduler runs commands at three fixed intervals (10 min, hourly, daily) with best-effort reliability. Posthook schedules at any future time via API with at-least-once delivery, retries, and observability. Posthook works on any platform, not just Heroku. https://posthook.io/compare/heroku-scheduler-vs-posthook ## Framework Guides ### Next.js Schedule durable timers from Next.js API routes and server actions. No cron, no workers, no infrastructure — just an API call and a handler. https://posthook.io/examples/nextjs ### Express Schedule durable timers from Express route handlers. No cron library, no Redis, no polling loop — just an API call and an endpoint. https://posthook.io/examples/express ### Python Schedule delayed tasks and webhooks from Python without Celery or Redis. SDK supports FastAPI, Flask, and Django with signature verification, async hooks, and ASGI/WSGI handler wrappers. https://posthook.io/examples/python ### Go Schedule delayed tasks and webhooks from Go with the standard library. Idiomatic Go SDK with typed errors, context.Context, and net/http-compatible signature verification. Async hooks with goroutines. https://posthook.io/examples/go ### Rails Schedule delayed tasks and webhooks from Rails without a Ruby SDK. Uses Net::HTTP for scheduling and OpenSSL::HMAC for signature verification — stdlib only. Works alongside Sidekiq for the timing-and-delivery subset. https://posthook.io/examples/rails ### Live Next.js Demo Interactive sandbox showing scheduling and delivery end-to-end. Try it without cloning. https://nextjs-posthook-scheduling.vercel.app ## Links - Website: https://posthook.io - Use Cases: https://posthook.io/use-cases - Documentation: https://docs.posthook.io - API Reference: https://docs.posthook.io/api-reference/introduction - Quickstart: https://docs.posthook.io/quickstart - Changelog: https://docs.posthook.io/changelog - Status: https://status.posthook.io - Community: https://github.com/posthook/community - Support: support@posthook.io - Twitter: https://twitter.com/posthook - GitHub: https://github.com/posthook ## Company Posthook, Inc. 169 Madison Ave STE 38542 New York, NY 10016 United States