How to Automate Document Signing with eSignature Webhooks (Without Paying for Seats You Don't Need)

Most eSignature platforms treat API access like a premium add-on — lock it behind enterprise tiers, charge per seat, and make you negotiate pricing before you've written a single line of code. If you're building signing automation into a product or workflow, that model punishes you for scaling.

GoodSign takes the opposite approach: $1.50 per envelope, no subscription, no user limits, and webhook support baked in from the start. For developer teams building document automation, that changes the math significantly.

Here's how to use eSignature webhooks to automate document signing end-to-end — CRM updates, Slack alerts, and everything in between.

What GoodSign Webhooks Actually Give You

Webhooks let your application react to signing events in real time instead of polling an API and hoping for the best. When something happens to a document, GoodSign fires an HTTP POST to your endpoint with a structured payload describing exactly what occurred.

The core webhook events you'll work with:

• signer_opened — a recipient opened the document
• signer_complete — an individual signer completed their signature
• document_complete — all parties have signed; the document is fully executed
• document_voided — the envelope was cancelled before completion
• signer_declined — a recipient actively declined to sign

Each payload includes the envelope ID, signer metadata, timestamps, and document status. That's enough context to trigger meaningful downstream actions without a secondary API call in most cases.

Automating CRM Updates When a Contract Is Signed

The most common use case: a prospect signs a contract, and your CRM deal should move automatically. Without webhooks, someone checks manually, updates the stage by hand, and the data is already stale.

With a document_complete webhook, you catch the exact moment all parties have signed and push that signal immediately. Your endpoint receives the payload, extracts the envelope ID (which you've already mapped to a deal ID on send), and calls your CRM's REST API to update the deal stage, set a close date, and log a note.

The practical implementation looks like this:

• Register your webhook endpoint in GoodSign's dashboard or via the REST API
• On document_complete, parse the envelope ID from the payload
• Look up the associated CRM record using your internal mapping
• PATCH the deal via your CRM's API (HubSpot, Salesforce, Pipedrive — all support this)
• Optionally trigger a follow-up sequence or task assignment

The document_voided event is equally important here. If a contract is cancelled, you want your CRM to reflect that immediately — not after a manual audit three days later.

Triggering Slack Alerts at Key Signing Milestones

Real-time Slack notifications are a straightforward win for any team managing contracts at volume. Account managers want to know when a client opened a proposal. Legal wants to know when an NDA is fully executed. Finance wants to know the moment a payment agreement is signed.

GoodSign's native Slack integration handles the simple version — notify a channel when a document is signed. But if you need conditional routing (alert this channel for contracts over $10k, a different channel for renewals), you'll want to handle it through webhooks directly.

Listen for signer_opened to send an early heads-up that a recipient is actively reviewing. Listen for document_complete to fire the final confirmation. Use the payload metadata to construct a meaningful message rather than a generic "document signed" ping that tells nobody anything useful.

Combining the REST API with webhooks gives you the full picture. Use the REST API to send envelopes programmatically at the start of your workflow, use webhooks to listen for outcomes at the end, and use Slack as the human-readable layer in the middle.

Why Pay-Per-Use Actually Matters for API-Heavy Teams

Subscription eSignature platforms charge per seat. That pricing model makes sense for teams where every person logs into a dashboard daily. It makes no sense for automated workflows where a backend service is sending envelopes on behalf of a system, not a named employee.

If you're running a SaaS product where document signing is one automated step in a larger workflow — think onboarding flows, contractor agreements, or client intake — you're paying for "users" that don't exist. Subscription platforms at scale can cost hundreds or thousands of dollars monthly before