Resources · Make integration

Sign Make integrationAutomate Sign with Make.

Can Make send contracts out for signature and collect them for you? The Sign Make integration gives you 15 modules: 1 scheduled trigger, 11 actions and 3 searches. If you already use Sign and are new to Make, this page walks you from the connection to a working first scenario.

Try the Sign integration on MakeSee the 15 modules

Verified Trustpilot reviews · AI, automation & growth agency

What you can automate

What can the Sign Make integration do for you?

The Sign Make integration links your Sign account to Make, a no-code tool where you build a scenario: an automation made of modules, each one a single brick such as a trigger, an action or a search. Sign then starts, cancels or tracks signing processes while the other apps you use keep up on their own.

Contracts that leave on time. When a deal is marked as won in your CRM, Initiate a new signing process sends the paperwork to Sign, and nobody has to rebuild it by hand. For sensitive terms, Initiate a Draft Process (UI Based) prepares it for a last review instead.

Signed copies filed where they belong. List IDs of Finished Processes spots what is done, and Get Finished Document by ID fetches the signed file so the next module can store it in your drive, next to the client record.

A clean pipeline. A deal that falls through? Cancel a Signing Process withdraws the pending request, and List Sign Processes feeds a tracking sheet so the team knows what is still waiting.

Know the limits before you start. Make itself says its documentation for Sign is incomplete, because little public information exists about the app: no field list, no connection guide, no troubleshooting notes. Test every module with Run once before trusting it. The Make troubleshooting guide helps when a run fails, and Make pricing explains how operations are counted.

Weighing tools? The n8n vs Make comparison sets out the criteria, and Make training covers the basics if this is your first scenario.

Connect

How do you connect Sign to Make?

  1. 01

    Add a Sign module

    In your scenario, click the + and search for Sign, then pick any of its modules. Make asks for a connection, meaning your Sign account linked to Make once and reused by every Sign module after that. Click Create a connection.

  2. 02

    Name and authorize the account

    Give the connection a name if you like, something that tells you which Sign account it is. Make then opens Sign's authorization page, or asks you to paste the key Sign gives you. Follow what the window shows.

  3. 03

    Save and check

    Click Save. The connection now appears in the module. To confirm it points at the right account, add Get the Current User and click Run once: the bundle that comes back (one item passed from a module to the next) shows who Make is acting as.

First scenario

Your first scenario with Sign

GoalWhen a process shows up in Sign, Make pulls its full details so the next step can use them.

  1. 01

    Create the scenario

    Open the Scenarios page in Make, create a new scenario and click the big + to add the first module. That first module decides when the whole chain starts.

  2. 02

    Add Watch Processes

    Search for Sign, pick Watch Processes and choose the connection you made earlier. Fill in what the module asks for; once the connection exists, Make lists what it can read in your account.

  3. 03

    Chain Get Process Information

    Click the + on the right of the trigger and add Get Process Information. In its fields, map the value from the Watch Processes bundle that identifies the process, instead of typing anything.

  4. 04

    Test with Run once

    Click Run once. Make runs the scenario a single time; open the bubble above each module to read the bundles it received and check that the details match a real process in Sign.

  5. 05

    Schedule and switch it on

    Click the clock on the first module. A new scenario runs every 15 minutes by default, and the Free plan cannot go below that. Then flip the switch to turn the scenario on.

Triggers

What starts a Sign scenario

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

Sign1Watch Processes

Watch Processes

triggerIn the docs only

Watch Processes looks at your Sign account and hands each signing process it picks up to the rest of the scenario as a bundle, so the following modules can react without anyone checking Sign by hand.

How it fires
scheduled: Make checks the app on the scenario's schedule, every 15 minutes by default and down to 1 minute on a paid plan.
When to use it
as the opening module whenever a process in Sign should set off something elsewhere, such as a message to the account manager or a new row in a tracking sheet.
Watch out
the documentation does not say which processes the trigger returns, new ones or updated ones, so read the bundles after a Run once before building on them.
Modules

What each Sign module does

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

Sign1

Cancel a Signing Process

ActionIn the docs only

Stops a signing process that is still under way, so nobody gets asked to sign a document you no longer want signed.

When to use it
a deal falls through in your CRM after the contract already went out, and the pending request has to disappear.
Watch out
the documentation mentions no way to undo a cancellation, so try it on a dummy process before you let a scenario run it for real.
Sign2

Cancels a Process (UI Based)

ActionIn the docs only

A second way to cancel a process. The UI Based label suggests it follows the path of Sign's own interface rather than the direct one, though the documentation does not confirm that.

When to use it
when Cancel a Signing Process does not behave as expected on a given process, test this one on the same case.
Watch out
nothing explains the difference between the two, so compare them with Run once before picking one.
Sign3

Encode a Document to Base64

ActionIn the docs only

Converts a document into Base64, a text version of the file that can travel inside a request where a regular file would not fit.

When to use it
just before Make an API Call, if the Sign request you are writing expects the file content as text.
Watch out
on the Free plan Make handles files up to 5 MB, so a large scanned contract may stop at this step instead of going through.
Sign4

Find a Process By Original Document

SearchIn the docs only

Tracks down the signing process that started from a given document, which spares you from keeping your own table of which file went where.

When to use it
a contract lands in a shared folder and you want to know whether it was already sent for signature before sending it again.
Watch out
as a search, it can return zero, one or several bundles, so plan for the case where nothing matches.
Sign5

Get Finished Document by ID

ActionIn the docs only

Hands you the signed document once its process is over, ready for the next module to store or forward, from the identifier you give it.

When to use it
right after List IDs of Finished Processes, to archive each signed copy next to the matching client record.
Watch out
the identifier has to come from an earlier module; typing one by hand works for a test but breaks as soon as a second contract arrives.
Sign6

Get Process Information

ActionIn the docs only

Brings the details Sign holds about one process into your scenario, so the next steps work with full context rather than a bare reference.

When to use it
after Watch Processes or a search, when the next module needs more than what the first bundle carried.
Watch out
the documentation lists none of the fields it returns, so run it once and read the bundle before you map anything from it.
Sign7

Get the Current User

ActionIn the docs only

Shows which Sign account the connection is acting as, a quick way to be sure your scenario sends from the right place.

When to use it
as a check at the start of a new scenario, or when you manage several Sign connections and want to confirm which one a module uses.
Watch out
each run costs an operation, the unit Make counts on your plan, so place it at the start rather than after a search that returns many bundles.
Sign8

Initiate a Draft Process (UI Based)

ActionIn the docs only

Sets up a process as a draft, going by its name, so someone can look it over in Sign before it goes further.

When to use it
contracts with sensitive terms, where a manager wants a final read before the signers see anything.
Watch out
the documentation says nothing on what a draft contains or how it gets sent afterwards, so open Sign after a Run once and check what was created.
Sign9

Initiate a new signing process

ActionIn the docs only

Launches a signing process in Sign straight from your scenario, so a contract leaves for signature as soon as the data behind it is ready.

When to use it
a deal marked as won, or a form filled in by a new supplier, should become a document to sign without anyone copying details over.
Watch out
no field list exists in the documentation, so open the module once the connection is saved and let Make show what it asks for.
Sign10

List IDs of Finished Processes

SearchIn the docs only

Returns, as bundles, the identifiers of processes that have reached the end, which gives you a clean starting list for collecting signed documents.

When to use it
to sweep finished contracts and pass each one to Get Finished Document by ID for filing.
Watch out
every bundle it returns makes the modules after it run once more, and each of those runs counts as an operation on your plan.
Sign11

List Sign Processes

SearchIn the docs only

Gives you an overview of the processes in your Sign account, delivered as a set of bundles you can sort, copy or report on.

When to use it
filling a tracking sheet with the processes still open, so the sales team sees at a glance which contracts are waiting on a signature.
Watch out
a long list means many operations downstream; narrow it with the module's own settings when Make offers any.
Sign12

Make an API Call

ActionIn the docs only

Opens the rest of Sign's API to your scenario, reusing the connection you already set up, for anything the listed modules leave out.

When to use it
you found the request you need in Sign's own API documentation and none of the modules on this page covers it.
Watch out
you write the request yourself, so keep that reference open and test with Run once before switching the scenario on.
Sign13

Resume a Signing Process

ActionIn the docs only

Gets a signing process moving again, judging by its name, after something brought it to a halt.

When to use it
a missing attachment held up a contract, and once the file is in place the process should carry on without anyone reopening Sign.
Watch out
the documentation gives no detail on which processes can be resumed, so test on a single process before letting a scenario resume them in bulk.
Sign14

Resume a Signing Process (UI Based)

ActionIn the docs only

The UI Based twin of Resume a Signing Process, worth having when the standard version does not fit how your processes were started.

When to use it
processes opened with Initiate a Draft Process (UI Based) may pair better with this one, though that is an inference from the names alone.
Watch out
nothing in the documentation separates the two versions, so run each once on a test process and keep the one that works.
Need help

Need help automating Sign with Make?

A person reads every message.

FAQ

Questions about Sign and Make

01Is the Sign Make integration free?
Yes, Sign is a standard app in Make, so you can use it from the Free plan. That plan has its own limits: 2 active scenarios, at least 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) bring the interval down to 1 minute, remove the cap on active scenarios and allow 40 minutes of execution. Usage is counted in credits, one operation for each module run on each bundle.
02What do you need to connect Sign to Make?
A Sign account and a Make account are enough to begin, as the documentation lists no other prerequisite. Add any Sign module, click Create a connection, name it if you want, then authorize Make on the Sign page or paste the key Sign provides, and click Save. Make's documentation for Sign is incomplete, so if the window asks for something unexpected, follow what Sign shows on screen and use Get the Current User afterwards to confirm the right account is linked.
03Does the Sign trigger in Make react in real time?
No. Watch Processes works as a scheduled trigger, going by its listing (the documentation only names it; look for the clock badge on the module): Make checks Sign on the scenario's schedule, which is every 15 minutes by default. On the Free plan that is also the shortest interval allowed, while paid plans can go down to 1 minute. There is no instant trigger for Sign, meaning no webhook where Sign would call Make the moment something happens. If a process needs quicker handling, shorten the interval on a paid plan rather than expecting a push from Sign.
04What if a Sign module is missing in Make?
Use Make an API Call. It reaches any endpoint of Sign's API with the connection you already have, so a feature without its own module is still within reach. You will need Sign's API reference to write the request, because Make's documentation for this app is limited and describes neither fields nor limits. Test each call with Run once and read the bundle that comes back before you connect it to the rest of the scenario.
05Make or n8n for Sign?
It depends on what you already run. On Make, Sign comes with 15 modules, a scheduled trigger and Make an API Call for the rest, and it works from the Free plan. The facts gathered here do not cover whether n8n offers a Sign node, so check its catalog before deciding. If your other automations already live in one of the two tools, keeping Sign there spares you a second tool to maintain, and the comparison page linked above sets out the criteria side by side.
Same platform

Other docs you might need on this stack.

Browse all integrations