Resources · Make integration

Signaturit Make integrationAutomate Signaturit with Make.

Stop copying signer details into Signaturit by hand. The Signaturit Make integration gives you 7 modules: 1 instant trigger and 6 actions. This guide connects your account, builds a first scenario and explains when each module earns its place.

Try the Signaturit integration on MakeSee the 7 modules

Verified Trustpilot reviews · AI, automation & growth agency

What you can automate

What can the Signaturit Make integration do for you?

The Signaturit Make integration links your Signaturit account to Make, a visual tool where you build a scenario: an automation made of modules, each one a brick that watches, creates or sends something. Your signature requests start from the tools you already use, with no code.

Contracts that leave on their own. A sales team can place Create a Signature Request from Template after the step where a deal is closed in another app, so the reusable contract goes out with the client's details already mapped.

Follow-ups nobody has to remember. Send a Signature Request Reminder nudges a signer from inside a scenario, and Cancel a Signature Request pulls back a request that should no longer be signed, for example when an HR offer is withdrawn.

A signal when a document moves. Watch Document Events is an instant trigger: Signaturit calls Make through a webhook as soon as something happens on a document, so the rest of your stack can react.

The listed modules cover requests, reminders and cancellations. For anything else in the Signaturit API, Make an API Call reuses the same connection. Signaturit's own documentation page in Make flags its content as AI-generated, so check important details with Signaturit. Weighing tools first? The n8n vs Make comparison and the Make pricing breakdown help, and the Make training covers the editor step by step.

Connect

How do you connect Signaturit to Make?

  1. 01

    Copy your Signaturit API token

    Open Signaturit, go to your account settings menu and click Integrations. The API token sits at the top of that tab: copy it. You need an active Signaturit account for this.

  2. 02

    Add a Signaturit module in Make

    In your scenario, pick any Signaturit module and click Create a connection. A connection is your Signaturit account linked to Make once, then reused by every Signaturit module. The Connection name field is optional.

  3. 03

    Paste the token and save

    Paste the token you copied, or follow the on-screen instructions, then save. From now on Make can read your Signaturit data and lists it in the module fields, so you pick values instead of typing them.

First scenario

Build your first scenario with Signaturit and Make

GoalWhen a new client record lands in another app, Make sends a Signaturit signature request built from your template.

  1. 01

    Create the scenario

    From the Scenarios page, create a new scenario and click the +. Add the module of the app where your client data appears, such as your CRM or form tool.

  2. 02

    Add the Signaturit action

    Click the + on the right of that first module, search Signaturit and pick Create a Signature Request from Template. Create or reuse your connection.

  3. 03

    Map the client data

    Fill the module fields. Make shows what it can read from Signaturit once connected, and you drag the details received from the first module into the matching fields.

  4. 04

    Test with Run once

    Click Run once and create a test record in the first app. Open each module's bubble to read the bundle it received, a bundle being one item passed from module to module.

  5. 05

    Schedule and switch it on

    Set the schedule on the first module with the clock (every 15 minutes by default), then switch the scenario on. Each module run counts as one operation on your Make plan.

Triggers

What starts a Signaturit scenario?

1 module starts a scenario when something happens in Signaturit. A scheduled trigger is checked by Make on the scenario's schedule; an instant one is called by Signaturit as soon as it happens.

Signaturit1Watch Document Events

Watch Document Events

Instant trigger

In Make“Triggers on document's events.”

This trigger lets your scenario react the moment something happens to a Signaturit document, instead of waiting for someone to check the dashboard. Each event arrives in Make as a bundle that the next modules can use, so a status change can update a spreadsheet, alert a manager or open a task elsewhere.

How it fires
instant, Signaturit calls Make through a webhook as soon as it happens.
When to use it
when a document event must be followed by an action in another tool, such as logging the outcome of a contract in your CRM.
Watch out
the module name does not spell out which events it sends, so run a test with Run once and inspect the bundle before building filters on it.
Modules

Which Signaturit modules can you use in Make?

Signaturit gives you 6 modules. For each one: what it does for you, when to reach for it, and what to watch out for.

Signaturit1

Cancel a Signature Request

Action

In Make“Cancels a signature request.”

You withdraw a pending request so the signer can no longer sign an outdated document, without logging into Signaturit.

When to use it
when a deal falls through or a quote is replaced in another tool and the old request must stop right away.
Watch out
a cancellation is final, so check the conditions that lead to this module and test it with Run once on a dummy request.
Signaturit2

Create an Email Request

Action

In Make“Creates a new email request.”

You get a new email request in Signaturit, built from data your scenario already holds, rather than a signature request.

When to use it
choose it over the signature modules when the process you run in Signaturit is based on email requests rather than signature requests, for example a message your client must receive from Signaturit itself.
Watch out
its fields only show up once your connection exists, so open the module and read them before you map anything.
Signaturit3

Create a Signature Request

Action

In Make“Creates a signature request.”

This action sends a document out for signature from inside a scenario, so a contract produced elsewhere reaches its signer without a manual upload.

When to use it
when each document is different, like a custom proposal generated for one client, and no Signaturit template fits.
Watch out
map every required field from earlier modules, then run a test on your own email address before switching the scenario on.
Signaturit4

Create a Signature Request from Template

Action

In Make“Creates a signature request from template.”

Your standard contract, prepared once as a Signaturit template, goes out automatically with the right signer each time a scenario runs.

When to use it
pick it over Create a Signature Request when the document never changes shape, such as an NDA or an employment offer.
Watch out
the template must exist in Signaturit before you set up the module, since Make can only list what your account already holds.
Signaturit5

Make an API Call

Action

In Make“Performs an arbitrary authorized API call.”

Here you reach any endpoint of the Signaturit API with the connection you already set up, which covers the jobs the six listed actions leave out.

When to use it
when you need a Signaturit feature that has no dedicated module in Make.
Watch out
you write the request yourself, so keep the Signaturit API documentation open and test with Run once before relying on the result.
Signaturit6

Send a Signature Request Reminder

Action

In Make“Sends a signature request reminder.”

A pending signer gets a nudge from Signaturit, triggered by your scenario, so nobody on the team has to chase signatures by hand.

When to use it
when a request is still unsigned and another app shows that the deadline is getting close, such as a contract start date in your project tool.
Watch out
each reminder is one operation, and repeated reminders can annoy a signer, so keep the conditions tight.
Need help

Need help automating Signaturit with Make?

A person reads every message.

FAQ

Signaturit and Make: frequent questions

01Is the Signaturit Make integration free?
Yes on the Make side, since Signaturit is a standard app available from the Free plan. That plan allows 2 active scenarios, a minimum of 15 minutes between two scheduled runs, 5 minutes of execution per run, files up to 5 MB and 512 MB of data transfer. Paid plans (Core, Pro, Teams and Enterprise) lower the interval to 1 minute, remove the cap on active scenarios and count usage in operations per month. You still need your own active Signaturit account, which Signaturit bills separately under its own pricing.
02What do you need to connect Signaturit to Make?
An active Signaturit account and its API token. In Signaturit, open the account settings menu, click Integrations and copy the token shown at the top of the tab. In Make, add any Signaturit module, click Create a connection, optionally name it, and paste the token. The connection is then reused by every Signaturit module in your scenarios. For the instant trigger, click Create a webhook before creating the connection, otherwise the module has nowhere to receive events.
03Does the Signaturit trigger in Make fire in real time?
Yes. Watch Document Events is an instant trigger: Signaturit calls Make through a webhook as soon as a document event happens, and the scenario starts with that event as its first bundle. There is no polling interval to wait for, unlike a scheduled trigger that Make checks every 15 minutes by default. The webhook has to be created on the module first. If you build a scenario that starts from another app instead, its own trigger decides how fast things move.
04What if a Signaturit feature is missing from Make?
Use Make an API Call. The Signaturit app in Make includes this module, which calls any endpoint of the Signaturit API with the connection you already created, so a missing feature does not force you to leave Make. You write the request yourself from the Signaturit API documentation. Also note that the Signaturit page of the Make documentation says its content is AI-generated and may contain mistakes, so confirm important behavior directly with Signaturit before automating it.
05Should you use Make or n8n for Signaturit?
It depends on where your team already builds automations. In Make, Signaturit comes with 7 ready modules, including an instant trigger and Make an API Call for the rest of its API, all set up through the visual editor. Many apps also have an n8n node, so check whether one exists for Signaturit and what it covers before you choose. Compare the modules each side offers for your use case rather than picking a tool on reputation alone.
Same platform

Other docs you might need on this stack.

Browse all integrations