---
title: "Automate eSignatures"
url: "https://docs.signnow.com/docs/clickup-zapier-signing-workflow"
type: "page"
section: "Integrations"
slug: "clickup-zapier-signing-workflow"
---
# Automate eSignatures
# Automate signing from ClickUp with Zapier
Send a document attached to a ClickUp task for signature, then file the signed copy in SharePoint and on the task.
**Use case overview**
A signing request starts from a ClickUp task: when the task reaches the agreed status, the file attached to it goes out for signature, and the signed copy is stored in SharePoint and re-attached to the originating task. The document travels as a file between the apps, so nobody downloads, re-uploads, or re-attaches anything by hand.
Signing is asynchronous — a signer may take minutes or days — so the workflow is built as two Zaps that hand off to each other through the document name.
Before you build the Zaps, connect your SignNow account to Zapier as described in [Getting started](/docs/clickup).
**Prerequisites**
- ClickUp, Microsoft SharePoint, and SignNow connected in Zapier
- A ClickUp list whose tasks carry the document to be signed as an attachment
- Two statuses on that list: one that starts the workflow, and a separate one for the signed result
- A SharePoint site and folder for signed documents
**Flow overview**
```mermaid
flowchart TD
A["ClickUp task reaches the signing status"] --> B["ZAP 1: read the attachment,
upload to SignNow, send the invite"]
B --> C["Signer receives an email and signs"]
C --> D["ZAP 2: SignNow reports the document complete"]
D --> E["SharePoint stores the signed PDF"]
D --> F["ClickUp attaches the signed PDF to the task"]
```
> [!WARNING]
> ClickUp's **Private Attachment Links** setting controls whether this workflow can read task attachments. Leave it off — the default — so attachment URLs stay reachable by Zapier. Find it under the Workspace avatar > **Settings** > **Security & Permissions** > **Advanced Permissions**.
## Name documents so the signed file finds its task
When SignNow reports a completed document, the event carries the document, not the ClickUp task it came from. The task ID travels with the document name and comes back the same way.
Zap 1 names every document it uploads:
```
CU-{clickup task id} — {original filename}
```
For example: `CU-869f64nre — sample-service-agreement`
Zap 2 reads the ID back out of that name, and uses the `CU-` prefix to recognise which completed documents belong to this workflow. Treat the document name as system-managed once the invite is out.
## Zap 1: send the document for signature
| Step | App | Event |
| :--- | :--- | :--- |
| 1 | ClickUp | Task Changes *(trigger)* |
| 2 | ClickUp | Find Task by ID |
| 3 | SignNow | Upload Document |
| 4 | SignNow | Invite to Sign |
### Step 1. Watch for a task status change
Add **ClickUp** as the trigger and choose the **Task Changes** event.
| Field | Required | Description / what to enter |
| :--- | :--- | :--- |
| **Workspace** | Yes | The ClickUp workspace holding the tasks. |
| **Space** | No | The space holding signable tasks. |
| **Folder** | No | The folder, or **No Folder**. |
| **List** | No | The list holding signable tasks. Select this before **Task Status**, which is populated from the list. |
| **What Changed?** | Yes | **Status**. The Zap then wakes only for status changes. |
| **Include Subtasks?** | No | **False**, unless subtasks also carry documents. |
| **Status Type** | No | Leave empty. |
| **Task Status** | No | The exact status that starts the workflow, for example `Complete`. |
Two fields narrow by status, and they work together. **Status Type** matches a whole category — `Open`, `Done (including closed)`, or `Closed` — and it filters what **Task Status** offers. Clear Status Type to see every status on the list; a Task Status already chosen is kept.
> [!WARNING]
> Scope the trigger with **Task Status**, not **Status Type**. Zap 2 sets the task to the signed status, which is itself a status change and wakes this trigger again. A trigger scoped to an exact status ignores it. A trigger scoped to the `Done` category matches any status in that category, sends a second invite, and the workflow loops.
Status names belong to the list, so pick from the dropdown rather than assuming a name.
### Step 2. Read the task and its attachment
Add **ClickUp** > **Find Task by ID**.
| Field | Required | Description / what to enter |
| :--- | :--- | :--- |
| **Task ID** | Yes | **Task Id** from step 1. |
| **Use Custom ID?** | No | **False**, unless the workspace uses custom task IDs. |
| **Include Subtasks?** | No | **False**. |
| **Successful if no search results are found?** | No | **False**, so a task that cannot be read halts the Zap instead of passing empty data on. |
| **If multiple search results are found** | No | Return first search result. |
This step returns the task's attachments. Zapier flattens them into fields prefixed `Attachments`:
| Field | Description |
| :--- | :--- |
| **Attachments Url** | Direct download link — the one to map into SignNow. |
| **Attachments Title** | The original filename, without its extension. |
| **Attachments Extension** | For example `pdf`. Useful for filtering. |
| **Attachments Mimetype** | For example `application/pdf`. |
| **Attachments Size** | File size in bytes. |
> [!NOTE]
> The trigger fires on a status change, and this step reads the attachment at that moment — so attach the document before the task reaches the signing status. When testing, attach a file first, then run the step, or the sample returns no `Attachments` fields.
Map **Attachments Url**. The `Attachments Url W Query` and `Attachments Url W Host` variants carry query parameters that open a preview.
If tasks can carry several attachments, add **Looping by Zapier** > **Create Loop From Line Items** over the attachment URL, with a Filter on **Attachments Extension** so only documents are sent.
### Step 3. Upload the document to SignNow
Add **SignNow** > **Upload Document**.
| Field | Required | Description / what to enter |
| :--- | :--- | :--- |
| **File** | Yes | **Attachments Url** from step 2. Zapier fetches the file and passes it on. |
| **Document Name** | No | `CU-` followed by **ID** from step 2, a separator, and **Attachments Title**. |
SignNow accepts `.doc`, `.docx`, and `.pdf` files here, and Zapier passes files up to roughly 150 MB. The action calls [Upload document](/docs/document/operations/upload-document).
The document arrives with no fillable fields, so the signer places a signature freely. To capture structured data — name, date, initials bound to a role — add the fields through the API as described in [Add fillable fields with an API request](#add-fillable-fields-with-an-api-request).
### Step 4. Send the invite
Add **SignNow** > **Invite to Sign**.
| Field | Required | Description / what to enter |
| :--- | :--- | :--- |
| **Document** | Yes | **ID** from step 3. |
| **From Email Address** | Yes | The sender address on your SignNow account. |
| **To Email Address** | Yes | **Assignees Email** from step 2. |
| **Subject** | No | For example `Signature requested:` followed by **Name** from step 2. |
| **Message** | No | Free text. Include the ClickUp task URL so the signer has context. |
| **Redirect After Signing** | No | A page to open once signing finishes. |
This action sends a [freeform invite](/docs/doc-freeform-invite/operations/post-freeform-document-id-invite): it addresses the signer by email address, and the signer places a signature anywhere on the document. Role-based invites are covered in the API section below.
## Add fillable fields with an API request
Two extra steps give the signer real fields instead of a free-form signature, while the document still comes from the ClickUp task. Both use SignNow's **API Request (Beta)** action, which signs each call with the SignNow connection already set up in Zapier.
Insert them between steps 3 and 4, and set **Stop on error** to **Yes** on both so a failed call halts the Zap.
### Step 3a. Add the fields
| Field | Description / what to enter |
| :--- | :--- |
| **HTTP Method** | `PUT` |
| **URL** | `https://api.signnow.com/document/` followed by **ID** from step 3 |
| **Additional request headers** | `Content-Type` / `application/json` |
| **Body** | The JSON below |
```json
{
"fields": [
{
"type": "signature",
"role": "Signer",
"required": true,
"page_number": 0,
"x": 100,
"y": 600,
"width": 200,
"height": 30
},
{
"type": "text",
"role": "Signer",
"label": "Full name",
"required": true,
"page_number": 0,
"x": 100,
"y": 650,
"width": 200,
"height": 20
}
]
}
```
Each field needs `type`, `role`, `required`, `page_number`, and its position and size. Coordinates are pixels from the top-left of the page, and `page_number` counts from `0`. Available types are `text`, `signature`, `initials`, `stamp`, `checkbox`, `attachment`, `hyperlink`, `radiobutton`, and `enumeration`. See [Edit document](/docs/document/operations/edit-document) for the full field reference.
> [!TIP]
> To place fields accurately, run this step once, open the document in SignNow and drag the fields where they belong, then call [Get document](/docs/document/operations/get-document) and copy the resulting coordinates back into the request body.
> [!NOTE]
> Fields are added while the document is still a draft. Each Zap run uploads a fresh document, so the step always has one to work with. Testing by hand against a document that has already been sent returns an error — upload a new document instead.
### Step 3b. Send a role-based invite
Fields are assigned to a **role**, and the invite binds that role to a person. Replace step 4 with a second **API Request (Beta)**:
| Field | Description / what to enter |
| :--- | :--- |
| **HTTP Method** | `POST` |
| **URL** | `https://api.signnow.com/document/` followed by **ID** from step 3, then `/invite` |
| **Additional request headers** | `Content-Type` / `application/json` |
```json
{
"to": [
{
"email": "signer@example.com",
"role": "Signer",
"order": 1,
"subject": "Signature requested",
"message": "Please review and sign."
}
],
"from": "sender@example.com"
}
```
Map **Assignees Email** from step 2 into the `email` value. In the Body box, type the JSON including its quotes, place the cursor between them, and press **/** to open the field picker so the token sits inside the quotes.
The `role` value must match the role set on the fields. See [Invite to sign](/docs/document-field-invite/operations/post-document-doc-id-invite) for the full request body, and the [Invite to sign](/docs/invite-to-sign) guide for how field and freeform invites differ.
## Zap 2: file the signed document
This is a separate Zap, with its own trigger. The two are linked only by the document name.
| Step | App | Event |
| :--- | :--- | :--- |
| 1 | SignNow | Document Completed *(trigger)* |
| 2 | Filter by Zapier | Only continue if… |
| 3 | Formatter by Zapier | Text > Extract Pattern |
| 4 | Microsoft SharePoint | Upload File |
| 5 | ClickUp | Post Attachment |
| 6 | ClickUp | Update Task |
### Step 5. Trigger on document completion
Add **SignNow** as the trigger and choose **Document Completed**.
| Field | Required | Description / what to enter |
| :--- | :--- | :--- |
| **Template** | No | Leave empty. These documents are uploaded rather than created from a template. |
| **Return PDF of Document** | Yes | **Yes**. This is what hands the signed file to the later steps. |
| **Return Document History** | Yes | **Yes** to make the audit trail available to later steps. |
| **Return ZIP** | Yes | **Yes** to receive the document and its history bundled together. |
The signed file arrives as the field **Files Pdf**. Both the SharePoint and ClickUp steps map that same field.
### Step 6. Filter out unrelated documents
Add **Filter by Zapier** and set one condition:
- **Document Name** — **(Text) Starts with** — `CU-`
The trigger fires for every document completed in the SignNow account, so the naming convention doubles as the scope for this Zap. Filters consume no tasks, so placing this before the Formatter also keeps usage down.
### Step 7. Extract the task ID
Add **Formatter by Zapier** > **Text**.
| Field | Description / what to enter |
| :--- | :--- |
| **Transform** | Extract Pattern |
| **Input** | **Document Name** from step 5 |
| **Pattern** | `CU-\s*([A-Za-z0-9]+)` |
The output is the bare ClickUp task ID. The `\s*` in the pattern allows for a space after the prefix.
### Step 8. Store the signed file in SharePoint
Add **Microsoft SharePoint** > **Upload File**.
| Field | Required | Description / what to enter |
| :--- | :--- | :--- |
| **Site** | Yes | The SharePoint site holding the destination folder. |
| **Document Library** | No | Usually `Documents`. |
| **Folder** | No | The folder for signed documents. |
| **File** | Yes | **Files Pdf** from step 5. |
| **File name** | No | **Document Name** from step 5. |
| **If file name exists** | No | **Rename automatically** keeps an earlier signed copy intact. |
### Step 9. Attach the signed file to the task
Add **ClickUp** > **Post Attachment**.
| Field | Required | Description / what to enter |
| :--- | :--- | :--- |
| **Workspace**, **Space**, **Folder**, **List** | Yes | Where the task lives. |
| **Task** | Yes | The **Output** from step 7. The field accepts a mapped value. |
| **File** | Yes | **Files Pdf** from step 5. |
> [!WARNING]
> Map the file itself into **File**, not the document name. A text value is accepted and converted into a `.txt` file, and the step still reports success — the task then carries a text file instead of the signed PDF. Check the step output: **Extension** reads `pdf` when the mapping is right.
### Step 10. Update the task status
Add **ClickUp** > **Update Task**.
| Field | Description / what to enter |
| :--- | :--- |
| **Task** | The **Output** from step 7. |
| **Task Status** | The signed status, for example `Signed`. |
Use a different status from the one the Zap 1 trigger watches.
## Test the workflow
1. Create a task in the scoped list, assign it to someone with a valid email, and attach a document.
2. Move the task to the signing status. Zap 1 runs.
3. Confirm the document name in SignNow begins with `CU-` and the correct task ID.
4. Sign the document from the invite email.
5. Within a minute or two, the signed PDF appears in the SharePoint folder and on the ClickUp task.
6. Watch the task after Zap 2 sets the signed status — one invite, and no second one.
7. Sign an unrelated document in the same SignNow account and confirm Zap 2 ignores it.
## Adapt the workflow
Use a SignNow template instead of the task attachment
A template carries fields drawn in advance and bound to a role, which gives the strongest data capture. The document then comes from SignNow rather than from the task.
Zap 1 becomes two steps:
1. **ClickUp** — Task Changes, configured as above
2. **SignNow** — Create Document From Template & Send Role Invite, with the template, a document name built the same way, the sender address, and the assignee's email mapped to the role
Creation and invite happen in one action, and no upload step is needed. In Zap 2, set the **Template** field on the trigger to the same template — that scopes the trigger, and the `CU-` filter becomes unnecessary.
Role fields appear in the Zapier editor once the template is selected. The action calls [Create document from template](/docs/template/operations/get-template-copy).
Use text tags in the source document
**Upload Document & Extract Fields** converts text tags already present in a document into fillable fields assigned to a role. It suits documents generated from a template that can carry tags — every file then arrives ready for signature.
Simple text tags hold each field's details in the document itself, for example `{{t:s;r:y;o:"Signer";w:100;h:15;}}` for a required signature assigned to the role `Signer`. See [Text tags](/docs/text-tags) for the syntax, and [Upload document with tags](/docs/document/operations/upload-document-with-text-tags) for the endpoint behind the action.
Because the fields are assigned to roles, pair this with the role-based invite described above.
Source the document from SharePoint
When the unsigned documents live in SharePoint rather than on the task, replace step 2 with **SharePoint** > **Find File in Folder**, matched on the ClickUp task ID in the filename, and pass the result to **Upload Document**.
Storing the SharePoint file path in a ClickUp custom field makes the match more reliable than matching on names.
Send to several signers
Use the document group actions: **Create Document Group From Template & Send Role Invite** in Zap 1, with a template group carrying one role per signer, and **Document Group Completed** as the Zap 2 trigger.
Signer addresses can come from ClickUp custom fields — an approver and a counterparty, for example. The action calls [Invite to sign doc group](/docs/doc-group-field-invite/operations/invite-to-sign-document-group).
Prefill fields with ClickUp data
Values held on the task — contract amounts, dates, client names — can be written into the document's fields when it is created, so the signer only signs.
**Find Task by ID** returns the task's custom fields, which are then available to map into the template's fields or into the `prefilled_text` property of an API-created field.
Route signed documents to different folders
Add **Paths by Zapier** to Zap 2 before the SharePoint step, branching on a ClickUp property such as client, project, or department, with a separate upload per branch.
Watch for declined and expired invites
The Zapier trigger reports completed documents. To act on a declined invite or an expired one, subscribe to SignNow's webhooks and catch the events with **Webhooks by Zapier**. See [Webhooks](/docs/guides-webhooks).
---
*Full page: https://docs.signnow.com/docs/clickup-zapier-signing-workflow*