Automation platform · All integrations

Connect Make to Formfy

Teams that rely on intake forms, consent documents, and signed waivers spend too much time moving data by hand — copying a submission into Airtable, attaching a signed PDF to a Notion page, or pinging the right Slack channel when a client finally signs. Make is already wired to hundreds of apps, but without a clean webhook from your form tool the automation chain breaks at the first step. The gap lives between "client signed" and "the rest of your stack knows about it."

Formfy ships a public REST API and a webhook firehose that plug directly into Make's custom webhook trigger. Drop in one scenario, subscribe to form.signed, and every signed consent or intake form routes into your Make workflows automatically.

Start a 15-day free trial Read the OpenAPI spec

The workflow at a glance

Trigger

A client signs a Formfy consent, intake, or waiver form

Action

Formfy fires a signed-form payload to Make's custom webhook trigger

Result

Your Make scenario routes the submission — and the signed PDF — into Airtable, Notion, Slack, or any connected app

Step-by-step: connect Make to Formfy

Wire Formfy webhook subscriptions into Make and run your first scenario on a signed-form trigger.

  1. Generate a Formfy API key

    Open the Formfy dashboard, navigate to Settings → API Keys, and click Create key. Copy the fk_live_… token to a password manager — Formfy displays it only once. During scenario development use a fk_test_… key to avoid billing live submission credits against test runs.

  2. Create a Make custom webhook trigger

    In Make, open your scenario editor and add a Webhooks → Custom webhook module as the trigger. Click the address link to copy the unique hook URL. Make generates a fresh endpoint per scenario — keep this URL handy because you will paste it into Formfy in the next step.

  3. Subscribe Formfy to the Make webhook URL

    POST /api/v1/webhooks with your Bearer token, setting target_url to the Make hook URL and event_types to ["form.signed"]. Formfy returns a signing secret — store it in Make as a scenario variable so each module can verify the X-Formfy-Signature header on every incoming delivery.

    POST/api/v1/webhooksSee in the OpenAPI spec →

  4. Map the signed-form payload in Make

    Run your scenario once with the custom webhook module waiting, then trigger a test signature in Formfy. Make captures the live payload and lets you map fields — submission_id, signer_email, form_id, signed_at — onto downstream modules. Confirm the payload structure before activating the scenario.

  5. Add an action module — write to Airtable, Notion, or Slack

    Pick a destination app in Make — Airtable Create record, Notion Create page, Slack Post message, or Google Sheets Add row. Map the Formfy fields you captured in the previous step onto the module inputs. Activate the scenario; every future signed form runs the full chain without manual work.

  6. Retrieve the signed PDF for file-storage scenarios

    Add an HTTP → Make a request module and call GET /api/v1/forms/{id}/signed-pdf, substituting form_id from the webhook payload. Formfy redirects to a time-limited download URL — pipe the resulting file into a Google Drive, Dropbox, or email module to archive or deliver the signed document automatically.

    GET/api/v1/forms/{id}/signed-pdfSee in the OpenAPI spec →

  7. Rotate the webhook secret on a quarterly schedule

    Quarterly — or any time the secret may have been exposed — POST /api/v1/webhooks/{id}/rotate-secret to generate a fresh signing key. Update the stored value inside your Make scenario immediately. Webhook deliveries fail closed until both Formfy and Make agree on the new secret, keeping the integration tamper-proof.

    POST/api/v1/webhooks/{id}/rotate-secretSee in the OpenAPI spec →

Subscribe Make to Formfy signed-form webhooks

Subscribe to the form.signed event. Make supplies the target_url from your Custom webhook module; Formfy returns a signing secret used to verify every delivery via X-Formfy-Signature.

curl -X POST https://formfy.ai/api/v1/webhooks \
  -H "Authorization: Bearer fk_live_YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "target_url": "https://hook.eu1.make.com/abc123yourhookpath",
    "event_types": ["form.signed"]
  }'

Frequently asked questions

Do I need a paid Make plan to connect Formfy via webhooks?

Make's free plan includes custom webhook triggers, so you can build and test your Formfy scenario at no cost. Free scenarios run on demand when triggered manually; always-on scheduled execution requires a Core or higher Make plan. Most production clinic and agency workflows — where forms are signed throughout the day — benefit from an always-on scenario. Formfy API access is included on every paid Formfy plan and the 15-day free trial.

Which Formfy events can trigger a Make scenario?

Five webhook event types are available in v1: form.created, form.sent, form.viewed, form.signed, and form.expired. form.signed is the most common trigger for CRM, file-storage, and notification workflows. Subscribe a single Make webhook to multiple event types by passing all of them in the event_types array when you POST /api/v1/webhooks, then use a Make router module to branch on the event field in each path.

How do I send a Formfy form from inside a Make scenario?

Add an HTTP → Make a request module and call POST /api/v1/forms/{id}/send with your Bearer token, the recipient's email or phone number, and an optional custom message. Formfy sends the form link by email or SMS within seconds. To create a brand-new form from a template before sending, call POST /api/v1/forms/generate in a preceding HTTP module and map the returned form_id forward.

How fast does Formfy deliver webhook payloads to Make?

Formfy queues webhook deliveries within seconds of the triggering event. If Make's endpoint is temporarily unavailable, Formfy retries with exponential backoff for up to 24 hours. Every delivery attempt — including HTTP status codes and response bodies — is logged in the Formfy dashboard's Webhook Deliveries panel, where you can inspect failures and replay any specific delivery manually.

Can I verify the Formfy webhook signature inside Make?

Yes. Every Formfy delivery includes an X-Formfy-Signature header computed as HMAC-SHA256 over the raw request body using the signing secret returned at webhook creation. In Make, add a Tools → Set variable module to recompute the HMAC and compare it to the header before the rest of your scenario runs. Discard payloads where the signatures do not match to protect the scenario from spoofed deliveries.

What happens if Make is offline when a form is signed?

Formfy retries delivery with exponential backoff for up to 24 hours. Once Make's endpoint responds, queued deliveries fire in order. You can also open the Formfy dashboard's Webhook Deliveries log at any time and replay a specific delivery — useful after a Make outage or a scenario misconfiguration that caused Make to reject the payload with a non-200 status.

How do I troubleshoot a Make scenario that stopped firing?

Three checks: (1) GET /api/v1/webhooks to confirm the subscription still lists the Make hook URL and the correct event_types; (2) inspect the Formfy Webhook Deliveries log for non-200 responses from Make; (3) confirm your Make scenario is active and the Custom webhook module has not been paused or deleted. Re-subscribe via POST /api/v1/webhooks if the endpoint URL has changed.

Can I trigger SMS form delivery from a Make scenario?

Yes. When you call POST /api/v1/forms/{id}/send inside a Make HTTP module, pass a phone number in the recipient field to trigger SMS delivery instead of email. Formfy's SMS channel is built in — no separate SMS provider or additional Make module required. This is useful for clinic appointment flows where the patient's mobile number is already stored in your CRM and you want the form delivered instantly.

Ready to wire Make into Formfy?

Spin up an API key, run your first webhook, and route signed forms wherever your team already works.

Start a 15-day free trialSee pricing